Systems and methods for storing and reading nucleic acid-based data with error protection

ABSTRACT

The systems, devices, and methods described herein provide scalable methods for writing data to and reading data from nucleic acid molecules. The present disclosure covers four primary areas of interest: (1) accurately and quickly reading information stored in nucleic acid molecules, (2) partitioning data to efficiently encode data in nucleic acid molecules, (3) error protection and correction when encoding data in nucleic acid molecules, and (4) data structures to provide efficient access to information stored in nucleic acid molecules.

REFERENCE TO RELATED APPLICATIONS

This application claims priority to and the benefit of U.S. ProvisionalPatent Application No. 62/714,557 filed on Aug. 3, 2018, and entitled“COMPOSITIONS AND METHODS FOR NUCLEIC ACID-BASED DATA STORAGE”, and isrelated to International Application No.: [ ], filed on Aug. 5, 2019,and entitled “SYSTEMS AND METHODS FOR STORING AND READING NUCLEICACID-BASED DATA WITH ERROR PROTECTION”. The entire contents of theabove-referenced applications are incorporated herein by reference.

BACKGROUND

Nucleic acid digital data storage is a stable approach for encoding andstoring information for long periods of time, with data stored at higherdensities than magnetic tape or hard drive storage systems. Currentmethods for nucleic acid digital data storage rely on encoding thedigital information (e.g., binary code) into base-by-base nucleic acidssequences, such that the base-to-base relationship in the sequencedirectly translates into the digital information (e.g., binary code)using multi-step chemistry. Sequencing of digital data stored inbase-by-base sequences that can be read into bit-streams or bytes ofdigitally encoded information can be error prone and costly to encodesince the cost of de novo base-by-base nucleic acid synthesis can beexpensive.

Reading times and costs may be prohibitive for data written withbase-by-base synthesis. Information stored at a high density (in termsof bits-per-base) may need high accuracy and high-resolution sequencingto read back. Indeed, data stored at or near the theoretical maximum of2 bits/base has similar stringency requirements for sequencing as doesgenomic information. This leaves little room for innovation overstate-of-the-art sequencers intended for genomic applications. Forreference, approximately 450B reads would need to be processed torecover a full TB of data, which can cost millions of dollars andthousands of hours to process. One method of sequencing is a nanoporesequencing. A key hurdle for nanopore sequencing has been achieving slowenough DNA translocation and narrow enough pores to sequence individualDNA bases.

SUMMARY

The systems, devices, and methods described herein provide nucleic aciddigital data storage encoding and retrieving methods that are lesscostly and easier to commercially implement than existing methods. Thesystems, devices, and methods described herein provide scalable methodsfor writing data to and reading data from nucleic acid molecules. Thepresent disclosure covers four primary areas of interest: (1) accuratelyand quickly reading information stored in nucleic acid molecules, (2)partitioning data to efficiently encode data in nucleic acid molecules,(3) error protection and correction when encoding data in nucleic acidmolecules, and (4) data structures to provide efficient access toinformation stored in nucleic acid molecules.

While the reading methods described herein may be used to read anynucleic acid sequence, the reading methods of the present disclosure areparticularly advantageous when reading information stored in nucleicacid sequences that were written into said sequences using an encodingmethod that writes data or information in identifier nucleic acidmolecules (also referred to herein as simply “identifiers” or“identifier molecules”). The nucleic acid sequence of each identifiermolecule corresponds to a particular symbol value (e.g., bit or seriesof bits), that symbol's position (e.g., rank or address), or both, in astring of symbols (e.g., a bit stream). For example, the presence orabsence of an identifier molecule could signal a bit value of one orzero, respectively (or vice versa). The identifier nucleic acidmolecules include combinatorial arrangements of component nucleic acidmolecules (also referred to herein as simply “components” or “componentmolecules”). The nucleic acid sequences of the components are separatedinto unique sets (also referred to as layers). Identifier molecules areassembled by ligating together (or otherwise assembling) multiplecomponent molecules, one component molecule selected from each layer.The set of possible identifier sequences corresponds to the variouspossible combinatorial combinations of the component sequences. Forexample, for C component sequences separated into M layers, with c_(i)representing the number of component sequences in each i^(th) layer, thenumber of possible identifier sequences that can be formed can berepresented by c₁×c₂× . . . ×c_(M). As an example, an encoding scheme of12 layers, each containing 10 component sequences can result in 10¹²different unique identifier sequences. If each identifier sequencecorresponds to a bit in a bit stream, this encoding scheme can represent1 TB of data.

Sequencing or reading nucleic acid molecules is often error-prone due todifficulty distinguishing between nucleotides (for example, because of apoor signal-to-noise ratio). Because symbols encoded using theabove-described methods are represented as identifier nucleic acidmolecules that are formed from a set of component molecules that areknown a priori, reading a sequence of a given molecule to determine theinformation encoded therein does not require an accurate reading of eachand every single base in that sequence. Instead, the reading methoddisclosed herein can tolerate a relatively high error rate, and stillcorrectly decode the digital information from the nucleic acidmolecules. To do that, portions of sequences that have been read can bematched to the known set of component sequences by using an approximatestring matching technique to determine which symbol in the string ofsymbols is most likely to be represented by the identifier molecule. Insome implementations, the component sequences are designed so that eachcomponent sequence is separated from each other component sequence by atleast a minimum number of base differences. Requiring the componentsequences to be distinct from one another in this manner reduces thechance that one sequence of a component molecule being sequenced will bemistaken for another component sequence when matching sequences. Thereading system of the present disclosure is therefore robust (e.g., lesssensitive to base errors), and identifier molecules can be read at afaster rate and with fewer errors than in traditional sequencing.

One way to improve tolerance to errors when reading data stored innucleic acid molecules is to include error protection symbols and errorcorrection schemes when encoding the data. To accomplish this, thesource data (e.g., the string of symbols) is split into blocks, a hashis calculated for each block, and the hashes are appended to the sourcedata at the end of each block to obtain a modified string of symbols,which is written into DNA. When the portion of the modified string ofsymbols corresponding to one of those hashes is read out from the DNA,it is compared to a hash computed on the read out symbols of thecorresponding block. A mismatch between the read out hash and thecomputed hash indicates a read error—e.g., the information extractedfrom the nucleic acid molecules does not match the source data. Tofurther improve tolerance to errors when reading data stored in nucleicacid molecules, an error protecting code such as a Reed-Solomon code canbe applied to source data or the above-modified string of symbols thatrepresents hashed source data. The Reed-Solomon code increases errortolerance, for both erroneous elements and element erasures, whenreading data.

Applying a uniform weight code to the data before writing it to nucleicacid molecules may also increase the efficiency of reading that databack from the nucleic acid molecules. Multiple identifier molecules maybe located in a pool having solid, liquid, or powder form. For example,identifier molecules may be formed in separate compartments then thecompartments may be consolidated to form the pool. A uniform weight codeensures that each pool has a certain number of identifier molecules. Thedata may be separated into words and then padded to form codewords, in amanner that ensures that each resulting codeword has the same number ofsymbols of a particular type (e.g., when symbols are bits, all codewordscould have the same number of bits having value 1), resulting in thecodewords having the same “weight.” For example, in an NchooseK encodingscheme, each pool would contain exactly K identifier sequences (notethat the pool or compartment includes populations of individualidentifier molecules, where each population of identifier molecules hasthe same identifier sequence. As used herein, “a number of identifiersequences” or “a number of identifiers” in a pool or a compartmentrefers to a number of populations of individual identifier molecules,where each population corresponds to the same identifier sequence.).When sequencing that pool, if fewer than K identifier sequences areread, that would indicate an error occurred during the sequencing. Onthe other hand, once K identifier sequences have been read duringsequencing, the sequencing process can stop, which can decrease theamount of sequencing time and improve efficiency.

One way to improve efficiency in reading information from DNA involvesusing a data structure to hold the location of data blocks of datastring. For example, a large data string may be separated and storedinto two or more containers. To determine which container containsinformation a user wants to access, the system may access a B-tree ortriple store structure that holds the location (e.g., container numberor placement). This allows a user to access the information he or she islooking for in an expedient manner—rather than reading the informationin each of the containers containing the data string.

The systems and methods described herein thus provide severalopportunities to decrease the cost and increase the throughput ofwriting information into nucleic acid molecules. First, a set ofcomponents can be reused and recombined to write new packets of digitalinformation. The expensive requirement to use base-by-base synthesis foreach new write job is thus replaced by a one-time base-by-base synthesiscost that may be amortized over several write jobs (e.g., 224 30-baseoligos at 10 μmol scale to write 860 terabit packets). Second, theencoded information is de-coupled from the sequences of DNA components,enabling the use of a large sequence design space that may be optimizedfor write, store, copy, query, and read operations. Third, the nucleicacid molecule encoding schemes described herein comprise enhanced errorcorrection and provide optimized operation speed.

In some aspects, encoded information is stored in nucleic acid moleculeswith error protection. Digital information is received as a first stringof symbols having length L1. Each symbol in the first string of symbolshas a symbol value and a symbol position within the first string ofsymbols. The symbols may be bits, bytes, a bit string of any length,alphanumeric characters, a character string of any length, or any othersuitable symbol. In some implementations, the string of symbols isconverted into a bit stream. For example, the string of symbols mayconsist of six symbols “LETTER”. The string of alphanumeric characters“LETTER” may be converted to binary, resulting in 48 bits (“0100110001000101 01010100 01010100 01000101 01010010”). In this example, L wouldbe equal to 48. In some implementations, the information in the stringof symbols is received separately—i.e., symbols may be receivedindividually or any combination. The symbols or groups of symbols maythen be concatenated or otherwise combined to form a string of symbols.For example, ten blocks of 8 bits may be received individually and thenconcatenated together to form a string of symbols 80 bits long.

In some implementations, there are three stages of encoding the receivedinformation: (1) hashing, (2) adding error protection symbols, and (3)determining codewords to represent the symbols. While the first stringof symbols may be encoded using all three of these stages, the stagesmay be performed separately or in any combination thereof. For example,the stages of hashing and adding error protection symbols may bebypassed, such that the information is only encoded as codewords. Thestages may be performed in any order.

In some implementations, the hashing stage begins by separating thestring of symbols is into blocks. In some implementations, each block isof the same length B, where B is equal to L (the length of the string ofsymbols) divided by the number of blocks. As an example, the string ofsymbols may be 1,000 bits. The 1,000 bits may be separated into anylength of blocks, such as five blocks each consisting of 200 bits; 100blocks each consisting of 10 bits; 10 blocks each consisting of 100bits, or any such combination. In some implementations, the blocks arenot of equal length. For example, for a string of 1,000 bits, block₁ mayconsist of 500 bits; block₂ of 100 bits; block₃ of 300 bits; and block₄of 100 bits.

In some implementations, a hash of length H is computed for each block.In some implementations, the hash is computed using one of MD5, SHA-224,SHA-256, SHA-384, SHA-512, SHA-512/224, or SHA-512/256. Each computedhash is appended to the corresponding block to form a hashed block. Thisallows string of symbols and the hashes to be stored together in nucleicacids. If each block is of length B, after appending the hash, thehashed blocks are of length H plus B. For example, the string of symbolsmay consist 1,000 bits that are then separated into ten blocks of 100bits each (B=100). The hash of each block may be 10 bits long (H=10).After appending, the hashed blocks then consist of 110 bits (theoriginal 100 bits plus the 100 bit hash). In some implementations, thehashes are alternatively or additionally stored separately from thestring of symbols. In some implementations H equals zero.

In some implementations, the hashed blocks are concatenated to form asecond string of symbols of length L2. In the example above, where eachhashed block of the ten hashed blocks comprises 1,100 bits, the stringof symbols would be equal to 1,100 bits (the original 1,000 bitsreceived plus 100 hash bits). In some implementations, the hashes arecomputed for each block but not appended; rather, the hashes are storedseparately. For example, the hashes may be stored on a hard drive inorder for the hashes to be accessed faster or more easily than theblocks in nucleic acids. The hashes could be stored in nucleic acidmolecules, a magnetic storage device, a flash memory device, cloudstorage, or any other suitable location.

In some implementations, the second string of symbols is separated intoslices. In some implementations, each slice is of the same length S,where S is equal to L2 (the length of the second string of symbolsformed from the hashed blocks) divided by the number of slices. As anexample, the second string of symbols may consist of 1,100 bits. The1,100 bits may be separated into any length of slices, such as tenblocks each consisting of 110 bits; one hundred slices each consistingof 11 bits; five slices of 220 bits, or any such combination. In someimplementations, the slices are not of equal length. For example, for astring of 1,100 bits, slice₁ may consist of 500 bits; slice₂ of 100bits; slice₃ of 300 bits; and slice₄ of 200 bits. In someimplementations, the hashing stage described above is bypassed. Thus,the second string of symbols of length L1 would be the same as thestring of symbols of length L1.

In some implementations, error protection symbols are computed for eachslice. Any number of error protection symbols may be computed for eachslice. The error protection symbols are appended to the slice for whichthey were computed, thereby forming error-protected slices. In someimplementations, the same number P of error protection symbols arecomputed for each slice, such that the each error-protected slice is Splus P bits long. For example, if the second string consists of 1,100bits that are separated into five blocks consisting of 220 bits each andP equals 40, 40 bits are appended to each slice resulting inerror-protected slices consisting of 260 bits each. In someimplementations, P equals zero.

In some implementations, the error protection symbols are determinedusing a Reed-Solomon code. Reed-Solomon codes are block-based errorcorrecting codes. If the P error protection symbols are computed using aReed-Solomon code,

$\frac{P}{2}$

erroneous bits can be tolerated.

For example, if P is equal to 40 for a 260-bit string, 20 of the 260bits may be incorrect without negatively affecting the processing ofthose 260 bits. If the P error protection symbols are computed using aReed-Solomon code, P erroneous bits can be tolerated. For example, if Pis equal to 40 for a 260-bit string, 40 of the 260 bits may be erasedwithout negatively affecting the processing of those 260 bits.

In some implementations, the error-protected slices are concatenated toform a third string of symbols having length L3. In the example above,where each error-protected slice of the five error-protected slicescomprises 260 bits, the third string of symbols would consist of 1,300bits (the original 1,000 bits received plus 100 hash bits plus 200 errorprotection bits determined). The third string of symbols of length L3 isequal to the second string of symbols of length L2 (i.e., the errorprotection bits may not be added). In some implementations, both thehashing and error protection stages are bypassed. In this case, thethird string of symbols of length L3 would be equal to the first stringof symbols of length L1.

In some implementations, the third string is separated into a pluralityof words, each word having length W. For example W may be equal to eightand each word would be eight bits long. In some implementations, acodeword is determined for each word using at least one codebook. Insome implementations, each codeword is an exact match of the respectiveword (i.e., nothing changes between the third and fourth strings ofsymbols). In some implementations, however, determining the codewordsaffects the length of each word.

Codewords may be optimized for chemical conditions during encoding ordecoding. As described above, the presence of an identifier may indicatea ‘1’ in a certain symbol position, while the absence of an identifierfor that position would indicate a ‘0’. In some implementations,determining the codewords comprises applying a uniform weight code tothe third string of symbols to ensure every word has the same number of‘1’s (i.e., identifiers to be constructed). Thus, a codeword must bechosen that encode eight bits. This effectively adds additional bits sothat each codeword can have an equal “weight” (number of identifiers tobe constructed). The codewords may be determined from a combinatorialspace in an NchooseK scheme. In an Nchoosek scheme, for every Nidentifier k identifiers are constructed. For example, in an 11choose4scheme, for every 11 identifiers, exactly four are constructed. An11choose4 scheme provides enough bits to encode 8 bits in each codeword.

In some implementations, fourth string of symbols having length L4 isformed by concatenating the codewords. The fourth string of symbols willcomprise

$\frac{L\; 3*N}{W}$

symbols. For example, for a string of 1300 bits (e.g., the third stringof symbols of length L3) if each word is 8 bits and an 11choose4 schemeis used, L4 would equal 1788.

In some implementations, each symbol in the fourth string is mapped toan individual identifier sequence. The mapping step produces a schemefor printing the digital information into nucleic acids with errorprotection. An individual identifier nucleic acid molecule of theplurality of identifier nucleic acid molecules corresponds to anindividual symbol in the fourth string of symbols. An individualidentifier comprises a corresponding plurality of components, whereineach component in the plurality of components comprises a distinctnucleic acid sequence. For example, the components may be selected fromM layers as described above.

In some implementations, the individual identifier molecules areconstructed by depositing and assembling corresponding components. Forexample, any of the printer/finisher systems described herein may beused to construct individual identifiers by depositing and assemblingcorresponding components in a compartment. In some implementations,dispensing, using a plurality of print heads, a plurality of solutionscomprising a plurality of components onto a coordinate on a substrate. Areaction mix may be dispensed onto the coordinate on the substrate tophysically link the plurality of components, provide a conditionnecessary to physically link the plurality of components, or both.

Based on the codeword stage, a set of printer instructions may bedeveloped that are then sent to a printer-finisher system. The printerinstructions may be configured to reduce the possibility of printingerrors or increase printing efficiency. For example, the codeword stagemay be designed to distribute the identifiers such that each compartmentin the plurality of compartments contains the same number of identifiernucleic acid molecules, thus providing uniform abundance of identifiersacross compartments. To provide additional error protection, in someimplementations, depositing the components into the compartments ispermuted such that identifier nucleic acid molecules that representadjacent symbols in the string of symbols are not constructed inadjacent compartments. This reduces the chances that printing mistakesmay cause undetectable errors due to printing onto the wrong coordinateor bleeding between compartments.

In some implementations, the individual identifiers are collected in apool. For example, a pool can hold hundreds of identifiers correspondingto hundreds of symbols encoded in the steps described above. In someimplementations, a presence or absence of an identifier in the pool isrepresentative of the symbol value of the corresponding respectivesymbol position within the string of symbols.

In some implementations, the hash, error protection, or codeworddetermination is performed on an individual block in the plurality ofblocks. The method of claim C14, wherein the hash, error protection, orcodeword determination is performed on the individual block and anadditional block in parallel. In some implementations, additional errorprotection symbols or hash symbols are stored in a magnetic storagedevice, an optical storage device, a flash memory device, or cloudstorage.

In some aspects, digital information is stored into nucleic acids with apartition scheme. The partition scheme may be designed with theintention of encoding the digital information in nucleic acids underrestraints, such as writing hardware configurations (e.g., the number ofinks available in a printer). Digital information is received as a firststring of symbols having length L. Each symbol in the first string ofsymbols has a symbol value and a symbol position within the first stringof symbols. The symbols may be bits, bytes, a bit string of any length,alphanumeric characters, a character string of any length, or any othersuitable symbol. In some implementations, the string of symbols isconverted into a bit stream. For example, the string of symbols mayconsist of six symbols “LETTER”. The string of alphanumeric characters“LETTER” may be converted to binary, resulting in 48 bits (“0100110001000101 01010100 01010100 01000101 01010010”). In this example, L wouldbe equal to 48. In some implementations, the information in the stringof symbols is received separately—i.e., symbols may be receivedindividually or any combination. The symbols or groups of symbols maythen be concatenated or otherwise combined to form a string of symbols.For example, ten blocks of 8 bits may be received individually and thenconcatenated together to form a string of symbols 80 bits long.

In some implementations, in order to encode within the given restraints,a partition scheme is determined. The partition scheme defines a set ofrules to encode the string of symbols using a set of C distinctcomponent sequences. Specifically, the partition scheme defines a numberof M layers within which to arrange the C distinct component sequences,and defines component sequences numbers in each layer, such that thereare c_(i) component sequences in the i^(th) layer. In someimplementations, the number of component sequences in each layer isnon-uniform (i.e., c₁ is not equal to c₂, etc.). The number of layersand number of component sequences may be configured to minimize thenumber of layers necessary to encode the string of symbols, therebysimplifying the chemistry of forming identifier molecules whilemaintaining enough identifier sequence possibilities to encode theentirety of the digital information. To ensure enough identifiersequence possibilities to encode the string of symbols, a product of thecomponent sequence numbers c_(i) (Π_(i=1) ^(L)c_(i)) must be greaterthan or equal to the length L of the string of symbols and a sum of thecomponent sequence numbers c_(i) (Σ_(i=1) ^(L)c_(i)) must be less thanor equal to the number C of distinct component sequences. In someimplementations, the identifiers are representative of a subset of acombinatorial space of possible identifier sequences, each including onecomponent from each of the M layers. As a simple example, if L equals1,000 (e.g., 1,000 bits in a bit stream received) and C equals 70 (e.g.,70 printer inks available to be printed), three layers (M=3) with 10component sequences per layer could be used to encode the data. However,to best capitalize on the available 70 component sequences, it may bemore efficient to encode the data using two layers (M=2), with 50component sequences in the first layer and 20 component sequences in thesecond layer.

In some implementations, if the string of symbols has been translated toa string of symbols of length B, the product of the component sequencenumbers c₁ must be greater than or equal to the length B of the stringof bits. For example, if the string of symbols is “LETTER”, L equals sixbut the equivalent string of bits consists of 48 bits (B equals 48).Thus, the number of M layers and C component sequences necessary toencode the string of bits having length B would be different than thenumber of layers needed to encode the a string of symbols having lengthL.

In some implementations, a first identifier is formed, for example witha printer/finisher system, by (i) selecting one component from each ofthe M layers, (ii) depositing the M selected components into acompartment, and (iii) physically assembling the selected components(ii). In some implementations, the selected components are assembled byligation. The first identifier includes first and second end moleculesand a third molecule positioned between the first and second endmolecules. The components from the first and second of the M layerscorrespond to the first and second end molecules of the identifiernucleic acid molecule, and the component in the third layer of the Mlayers corresponds to the third molecule of the identifier, therebydefining a physical order of the M layers in the first identifiernucleic acid. In some layers, the M layers are associated with differentpriority levels. For example, the first layer may have a highestpriority and the second layer may have a second highest priority. Theremaining M−2 layers may have corresponding components between the firstand second end molecules.

In some implementations, additional identifiers are formed. Theadditional identifiers correspond to respective symbol positions in thestring of symbols that represents the digital information to be encoded.Each symbol position within the string of symbols may have acorresponding different identifier. In some implementations, once thenecessary amount of identifiers are formed, the identifiers arecollected in a pool.

In some aspects, information is read from nucleic acid sequences. Insome implementations, a pool of identifiers is obtained. The identifiersin the pool store digital information from a string of symbols of lengthL. The pool of identifiers corresponds to a subset of identifiersequences in an identifier library that is capable of encoding anystring of symbols having length L. Each individual identifier in thepool corresponds to a symbol value and a symbol position in the stringof symbols. Each individual identifier comprises a plurality ofcomponents and is thus an instance of a specific sequence. In someimplementations, the pool comprises gene-, peptide-, or RNA-encodingDNA.

The identifier may be processed in various ways. In someimplementations, the identifier is ligated to a second identifier. Insome implementations, one strand of the identifier is degraded. Forexample, a strand-specific exonuclease may be used to selectivelydegrade one strand of the identifier.

In some implementations, at least one of the obtained identifiers isread to obtain a read sequence corresponding to a portion of the atleast one identifier. The read sequence may be obtained via anysequencing technique, such as chemical sequencing, chain terminationsequencing, shotgun sequencing, bridge PCR sequencing, single-moleculereal-time sequencing, ion semiconductor sequencing, pyrosequencing,sequencing by synthesis, combinatorial probe anchor synthesissequencing, sequencing by ligation, nanopore sequencing, nanochannelsequencing, massively parallel signature sequencing, Polony sequencing,DNA nanoball sequencing, single molecule fluorescent sequencing,tunneling current sequencing, sequencing by hybridization, massspectrometry sequencing, microfluidic sequencing, transmission electronmicroscopy sequencing, RNA polymerase sequencing, or in vitro virussequencing. Sequencing a pool of nucleic acids, identifiers in thiscase, yields a read sequence for the whole pool; however, it is notknown how each identifier of the pool maps to the read sequence.Sequencing methods are prone to single-base errors, further hinderingthe matching of identifiers to the read sequence.

In some implementations, the read sequence may be obtained via nanoporesequencing. An electric field is applied to an electrolytic solution andat least one nanopore channel. In some implementations, the at least onenanopore channel is formed within a solid-state membrane. In someimplementations, the nanopore channels are formed from alpha-hemolysin(αHL) or Mycobacterium smegmatis porin A (MspA). During nanoporesequencing, the identifier is translocated through the at least onenanopore channel, while impedance across the channel is measured. Eachcomponent in the identifier has a corresponding unique impedancesignature along the length of the component sequence, thus allowing thecomponents in the read sequence to be determined by comparing measuredimpedance values to the unique impedance signature.

In some implementations, if the identifier is read using nanoporesequencing, the applied electric field generates a differentialpotential greater than or equal to 100 mV. This high differentialpotential enables the identifier to be passed through the nanoporechannels at a relatively high rate. For example, translocation of theidentifier may occur at a rate great than 1,000 bases per second. Inparticular, the translocation rate may be 1,000,000 bases per second.

In some implementations, when reading the identifier includes nanoporesequencing, an agent is bound to the identifier before translocating.For example, the agent may be a chemical moiety, a protein, an enzyme, abase analogue, a conjugated nucleic acid, a nucleic acid with a hairpin,or a methyl group. In some implementations, if the agent is a chemicalmoiety, an enzyme, such as methyltransferase, binds the chemical moietyto the at least one identifier nucleic acid molecule. In someimplementations, if the agent is a base analogue and the agent is boundusing an enzyme, such as a polymerase, the enzyme binds the baseanalogue to the at least one identifier nucleic acid molecule duringreplication.

In some implementations, the agent is associated with an agent signaturethat may be used to help determine sequences in the identifier duringreading. Binding the agent to the at least one identifier nucleic acidmolecule occurs at a known location on a component of the identifier,such that the agent signature at the known location results in a knownshift in impedance value during translocation. The presence of the agentmay thus create an exaggerated “profile” for the identifier, therebyincreasing the signal-to-noise ratio during reading. This may allow thetranslocation speed to be increased while maintaining accuracy duringreading. In particular, the presence of the agent on the at least oneidentifier may allow for a first maximum translocation rate thatachieves a desired level of accuracy that is faster than a secondmaximum translocation rate that achieves the desired level of accuracyin the absence of the agent on the at least one nucleic acid molecule.Another way to increase signal-to-noise ration during reading includesreplicating the identifier such that it comprises modified bases or baseanalogues. This may done separately or in addition to binding an agentto the identifier.

In some implementations, the methods described herein includes matchingthe read sequence to a known set of identifier sequences (i.e., theidentifier library). The read sequence is used to identify a set ofcandidate identifier sequences from the identifier library that have acomponent sequence that approximates or exactly matches the readsequence. As an example, the read sequence (which may or may notcorrectly match the identifier) may be CAGCTG. The set of candidateidentifier sequences may comprise an exact match (CAGCTG) as well asother potential matches that are similar to the read sequence, such asidentifier sequences that differ by a certain number of bases (e.g., 1,2, 3, 10, 20, 100, etc.). For example, the set of candidate identifiersequences may also include CAGATG, AAGCTA, and CACGTG. For ease ofreference, the “incorrect” nucleotides (i.e., that do not match the readsequence in the example) are underlined.

In some implementations, the identifiers are encoded with errortolerance symbols such that identifier is associated with a readingerror tolerance. This reading error tolerance may be used to limit therate at which the identifier is read. Another way to increase readspeeds includes reading a subset of the identifier. In someimplementations, the identifier includes M components corresponding to Mlayers. In some implementations, reading the identifier includes readingonly N of the M components where N is less than M. For example, only thefirst two layers out of five layers may be read. While this lowers theresolution of the read, it can increase how many identifiers are read ina given amount of time. This can be helpful when a subset of the dataencoded in the pool needs to be accessed. For example, if the firstlayer always indicates a certain meaningful value, certain usefulidentifiers can be identified by only accessing the first layer.

In some implementations, each candidate identifier sequence is assigneda score associated with how similar the component sequence of eachcandidate identifier sequence is to the read sequence. The better thecandidate identifier sequence matches the read sequence, the lower (orhigher) the score may be. The scores may be computed in a variety ofways including a least distance algorithm, a percent match, or any othersuitable algorithm. As an example, for the read sequence CAGCTG, acandidate sequence CAGCTG may have a score of zero, while a candidatesequence CAGATG may have a score of one because the fourth base of thecandidate sequence does not match the read sequence. The score maydepend on the number of bases that are incorrect and/or the placement ofincorrect bases. For example, a candidate with two incorrect nucleotidesadjacent one another (CACGTG) may have a lower score than a candidatewith two incorrect nucleotides that are not adjacent (AAGCTA).

In some implementations, the set of scores guides the selection of oneof the candidate identifier sequences as a potential match to theidentifier, thereby mitigating the effect of single-base sequencingerrors. For example, the candidate sequence with the lowest score may beselected because it is the closest potential match to the read sequence.In some implementations, the selected candidate identifier sequence isthen mapped to a symbol position and symbol value using the identifierlibrary. In some implementations, for example if reading the identifiersincludes nanopore sequencing and an agent has been bound to theidentifier, determining the sequence in the identifier includescomparing measured impedance values during translocation to the agentsignature.

In some implementations, the steps above are iterated until the desireddigital information is completely accessed from the pool (or multiplepools) of identifiers. In some implementations, a decoded string ofsymbols is determined and tested for accuracy. Specifically, a hash of aportion of the decoded string of symbols may be calculated then comparedto a hash associated with a corresponding portion of the string ofsymbols that was received. The hash may be stored as an identifier orcomponent in the pool (and subsequently read), or may be storedremotely. When the portion of the modified string of symbolscorresponding to one of these hashes (i.e., an original hash storedseparately from the DNA or a hash read out from the identifier), it iscompared to a hash computed on the read out symbols of the correspondingblock. The hash may be calculated using MD5, SHA-224, SHA-256, SHA-384,SHA-512, SHA-512/224, or SHA-512/256 or any other suitable algorithm. Amismatch between the read out or original hash and the computed hashindicates there was a read error in reading the data—e.g., theinformation extracted from the nucleic acid molecules does not match thesource data. Based on whether the calculated hash matches the read outoriginal hash, the portion of the decoded string of symbols may beverified as a match to the portion of the string of symbols received. Ifthe hashes do not match (or if it is determined the decoded string doesnot match the obtained string through any other means), a differentcandidate identifier sequence (e.g., of the set of candidate identifiersequences) may be selected. As identifiers are decoded and verified, acomputer system may track this information and use a machine learningtechnique to increase a likelihood that the decoded string of symbolsmatches the string of symbols. The error-tolerant method thus sets abasis for making unconventional improvements to sequencing techniques,for example running nanopore sequencing at a substantially large appliedvoltage, as described above.

In terms of grams, the total amount of material in a given pool may bein microgram quantities. To accurately read the molecules in the pool,it may be amplified to ensure enough material exists for redundancy,archiving, and accessing. For example, a PCR amplification scheme foraccessing a sub-library of identifiers from an archived DNA library maybe used. A sub-library may be any group of identifiers that one wishesto access, such as a data block, several data blocks, a singleidentifier, several identifiers, etc. The amplifications process mayinclude two primary steps. In the first amplification step with (A)primers, the desired data block is selected and enriched; in the secondwith (B) primers, amplicons are prepared for sequencing. The first step(A) is intended to select specific targets, using the unique primers andonly a few PCR cycles, and the second step (B) is intended to thenamplify the target sequences of the specific targets, not including theprimers, to generate a large amount of molecules for sequencing. Withthis nested approach for amplification, the number and identity ofidentifiers accessed is adjusted and the sequencing burden is reduced.In some implementations, amplification steps are limited to 7 cycles orless to reduce amplification bias in the libraries and to maintainuniformity of sequence abundance. Primer combinations may be validatedwith identifiers to demonstrate efficiency and uniformity of theamplification process. Initial optimization will be measured by qPCR.The level of product purity may be determined by using PCR cleanuprequirements (e.g., ExoSAP-IT, ThermoFisher) by measuring both qPCRamplification efficiency and sequencing the presence of partialsequencing products.

It may also be advantageous to selectively enrich the molecules withtags to increase the speed of accuracy of reading. Similar to how thenucleic acid molecules can be tagged for better signal resolution innanopore sequencing, each component or identifier may be tagged with aspecific probe/adapter that allows for other selection techniques likeprotein- or magnet-based selection protocols. Examples of methods ofenrichment, include i) streptavidin coated magnetic beads, ii) Ampure XPsize selection, iii) specific primer capture by Watson-Crick baitsequences.

In some implementations, nucleic acid molecules may be read usingnanopore sequencing. Certain methods for nanopore sequencing involvesligation of adapter protein complexes to nucleic acid molecules. Someadapter proteins act as a hydrophobic tether allowing for the nucleicacid molecules to target the lipid bilayer reducing the time nanoporesare unoccupied. Another protein, or motor, such as α-hemolysin separatesthe double-stranded nucleic acid molecules so that a single-strandenters the nanopore. This motor then helps ratchets the single-strandednucleic acid molecules through the nanopore. This protocol is entirelycompatible with the identifier libraries and amplicon enrichment plandescribed herein.

To increase sequencing efficiency, it may be advantageous to optimizenanopore sequencing by physically concatenating identifiers in amplifiedsub-libraries. Nanopore sequencing may require target nucleic acidmolecules to find nanopores, which contributes to reading speed. Inorder to increase read time identifiers may be physically concatenatedinto longer molecules by ligation. By increasing the length of sequencedmolecules from less than 500 bp to 5,000 bp (or greater), pore occupancymay be maximized.

The speed that nucleic acid molecules translocate through the nanoporemay be increased. Current nanopore sequencing instruments translocatenucleic acid molecules through nanopores at a rate of 500 base pairs persecond. Establishing a differential membrane potential (e.g., greaterthan 100 mV) across a nanopore membrane translocates nucleic acidmolecules at a higher rate (e.g., greater than 1,000 or −1,000,000 basesper second). For most sequencing applications, a rate on the order ofhundreds of thousands is too rapid and protein “motors” can be used toratchet nucleic acid molecules through the pore in order for a singledistinct base to be detected. Thus running nanopore sequencing without a“motor” may need generating single-stranded nucleic acid molecule inputand amplification of nucleic acid molecule signal. Several methods existfor asymmetric PCR that achieve greater than 50% single-stranded nucleicacid molecules from a reaction. By adjusting primer-melting temperature,amplification primers can be designed to drive the reaction into linearamplification of one strand. Alternatively, strand-specificexonucleases, such as Lambda exonuclease, can be used to bindspecifically to 5′ phosphorylated nucleic acid molecule strands andselectively degrade one strand of the duplex. The protocol may providegreater than 90% production of single-strand molecules.

Regarding signal amplification, nucleic acid molecules can be modifiedwith agents to enhance the signal to noise ratio, essentially creating a“super signature”. For example, agents can be small molecules, chemicalgroups, base analogues, enzymes, proteins, protein complexes, peptides,or amino acids. One method for nanopore signal enhancement, mTAG(methyltransferase-directed transfer of activated groups), uses amethyltransferase to add a chemical group, like biotinylatedS-adenosyl-L-methionine cofactor analogue, to the N6 atom of the adeninebase in a sequence motif. If the agent is a base analogue, it can beadded to the identifier molecule through PCR in which the base analogueis included in reaction mix and is incorporated into a complementarystrand bound to a single strand of the identifier molecule duringreplication. The new hybrid of identifier molecule with base analoguecan then be sequenced, and the base analogue can improve signal to noiseratio in a sequencing readout.

BRIEF DESCRIPTION OF THE DRAWINGS

The foregoing and other objects and advantages will be apparent uponconsideration of the following detailed description, taken inconjunction with the accompanying drawings, in which like referencecharacters refer to like parts throughout, and in which:

FIG. 1 shows a base module of a printer-finisher system, according to anillustrative implementation;

FIGS. 2A-B show a printer engine rack and the positioning of printheads, according to an illustrative implementation;

FIG. 3 shows a diagram of dispensing solutions into compartmentsaccording to a trie of identifiers, according to an illustrativeimplementation;

FIG. 4 shows a pooling sub-system, according to an illustrativeimplementation;

FIG. 5 shows an archival information system, according to anillustrative implementation;

FIG. 6 shows a system diagram of an operating system organized by layer,according to an illustrative implementation;

FIG. 7 shows system diagram of a layered product constructor with threelayers and a component library of eight components, according to anillustrative implementation;

FIG. 8 shows a flowchart for storing digital information into nucleicacid molecules with error protection, by appending hashes, according toan illustrative implementation;

FIG. 9 shows a flowchart for storing digital information into nucleicacid molecules with error protection, by separately storing hashes,according to an illustrative implementation;

FIG. 10 shows a flowchart for storing digital information into nucleicacid molecules, using a partition scheme, according to an illustrativeimplementation;

FIG. 11 shows a system diagram of a uniform weight code, according to anillustrative implementation;

FIG. 12 shows a system diagram of a decoding stack, according to anillustrative implementation;

FIG. 13 shows a flowchart for reading information stored in nucleic acidsequences, according to an illustrative implementation;

FIG. 14 shows a PCR amplification scheme, according to an illustrativeimplementation;

FIGS. 15A-B show identifier nucleic acid molecules with signal events,according to an illustrative implementation;

FIG. 16 shows a system diagram of archival operations, according to anillustrative implementation;

FIG. 17 shows a system diagram of writing data, according to anillustrative implementation; and

FIG. 18 shows a flowchart for storing blocks of data in containers,according to an illustrative implementation.

DETAILED DESCRIPTION

To provide an overall understanding of the systems, method, and devicesdescribed herein, certain illustrative embodiments will be described.Although the embodiments and features described herein are specificallydescribed for use in connection with nucleic acid-based data storage, itwill be understood that all the components and other features outlinedbelow may be combined with one another in any suitable manner and may beadapted and applied to other types of data storage and nucleic acidtechnology.

There is a need for nucleic acid digital data storage encoding andretrieving methods that are less costly and easier to commerciallyimplement than existing methods. The systems, devices, and methodsdescribed herein provide scalable methods for writing data to andreading data from nucleic acid molecules. The present disclosure coversfour primary areas of interest: (1) accurately and quickly readinginformation stored in nucleic acid molecules, (2) partitioning data toefficiently encode data in nucleic acid molecules, (3) error protectionand correction when encoding data in nucleic acid molecules, and (4)data structures to provide efficient access to information stored innucleic acid molecules.

While the reading methods described herein may be used to read anynucleic acid sequence, the reading methods of the present disclosure areparticularly advantageous when reading information stored in nucleicacid sequences that were written into said sequences using an encodingmethod that writes data or information in identifier nucleic acidmolecules (also referred to herein as simply “identifiers” or“identifier molecules”). The nucleic acid sequence of each identifiermolecule corresponds to a particular symbol value (e.g., bit or seriesof bits), that symbol's position (e.g., rank or address), or both, in astring of symbols (e.g., a bit stream). For example, the presence orabsence of an identifier molecule could signal a bit value of 1 or 0,respectively (or vice versa). The identifier nucleic acid moleculesinclude combinatorial arrangements of component nucleic acid molecules(also referred to herein as simply “components” or “componentmolecules”). In some implementations, the nucleic acid sequences of thecomponents are separated into unique sets, also referred to as layers.Identifier molecules are assembled by ligating together (or otherwiseassembling) multiple component molecules, one component moleculeselected from each layer. The set of possible identifier sequencescorresponds to the various possible combinatorial combinations of thecomponent sequences. For example, for C component sequences separatedinto M layers, with c_(i) representing the number of component sequencesin each i^(th) layer, the number of possible identifier sequences thatcan be formed can be represented by c₁×c₂× . . . ×c_(M). As an example,an encoding scheme of 12 layers, each containing 10 component sequencescan result in 10¹² different unique identifier sequences. If eachidentifier sequence corresponds to a bit in a bit stream, this encodingscheme can represent 1 Tb of data. Examples of various methods ofwriting digital information into nucleic acid molecules are in U.S.application Ser. No. 15/850,112 entitled “NUCLEIC ACID-BASED DATASTORAGE”, filed Dec. 21, 2017 and published as U.S. Patent PublicationNo.: 2018/0137418; U.S. application Ser. No. 16/461,774 entitled“SYSTEMS FOR NUCLEIC ACID-BASED DATA STORAGE”, filed May 16, 2019; andU.S. application Ser. No. 16/414,758 entitled “COMPOSITIONS AND METHODSFOR NUCLEIC ACID-BASED DATA STORAGE”, filed May 16, 2019, each of whichis hereby incorporated by reference.

Sequencing or reading nucleic acid molecules is often error-prone due todifficulty distinguishing between nucleotides (for example, because of apoor signal-to-noise ratio). Because symbols encoded using theabove-described methods are represented as identifier nucleic acidmolecules that are formed from a set of component molecules that areknown a priori, reading a sequence of a given molecule to determine theinformation encoded therein does not require an accurate reading of eachand every single base in that sequence. Instead, the reading methoddisclosed herein can tolerate a relatively high error rate, and stillcorrectly decode the digital information from the nucleic acidmolecules. To do that, portions of sequences that have been read can bematched to the known set of component sequences by using an approximatestring matching technique to determine which symbol in the string ofsymbols is most likely to be represented by the observed (or read)identifier molecule. In some implementations, the component sequencesare designed so that each component sequence is separated from eachother component sequence by at least a minimum number of basedifferences (for example, a minimum Hamming distance or Levenshteindistance). Requiring the component sequences to be distinct from oneanother in this manner reduces the chance that one sequence of acomponent molecule being sequenced will be mistaken for anothercomponent sequence when matching sequences. The reading system of thepresent disclosure is therefore robust (e.g., less sensitive to baseerrors), and identifier molecules can be read at a faster rate and withfewer errors than in traditional sequencing, as is explained in furtherdetail below, with reference to FIG. 12 and FIG. 13.

One way to improve tolerance to errors when reading data stored innucleic acid molecules is to include error protection symbols and errorcorrection schemes when encoding the data. To accomplish this, thesource data (e.g., the string of symbols) is split into blocks, a hashis calculated for each block, and the hashes are appended to the sourcedata at the end of each block to obtain a modified string of symbols,which is written into DNA. When the portion of the modified string ofsymbols corresponding to one of those hashes is read out from the DNA,it is compared to a hash computed on the read out symbols of thecorresponding block. A mismatch between the read out hash and thecomputed hash indicates a read error—e.g., the information extractedfrom the nucleic acid molecules does not match the source data. Tofurther improve tolerance to errors when reading data stored in nucleicacid molecules, an error protecting code such as a Reed-Solomon code canbe applied to source data or the above-modified string of symbols thatrepresents hashed source data. The Reed-Solomon code increases errortolerance, for both erroneous elements and element erasures, whenreading data, as described in further detail below with reference toFIGS. 8-9.

Applying a uniform weight code to the data before writing it to nucleicacid molecules may also increase the efficiency of reading that databack from the nucleic acid molecules. Multiple identifier molecules maybe located in a pool having solid, liquid, or powder form. For example,identifier molecules may be formed in separate compartments then thecompartments may be consolidated to form the pool. A uniform weight codeensures that each compartment has a certain number of identifiermolecules. The data may be separated into words and then translated toform codewords, in a manner that ensures that each resulting codewordhas the same number of symbols of a particular type (e.g., when symbolsare bits, all codewords could have the same number of bits having value1), resulting in the codewords having the same “weight.” For example, inan NchooseK encoding scheme, each codeword may be represented by theidentifiers formed in one compartment, and each compartment wouldcontain exactly K identifier sequences of N possible sequences (notethat the pool or compartment includes copies of individual identifiermolecules, where each copy of identifier molecules has the sameidentifier sequence. As used herein, “a number of identifier sequences”or “a number of identifiers” in a pool or a compartment refers to anumber of copies of individual identifier molecules, where each copycorresponds to the same identifier sequence.). When sequencing that poolor compartment, if fewer than K identifier sequences are read (orobserved) for the N possible sequences that represent a codeword, thatwould indicate that there is insufficient data to interpret the value ofthe codeword. We may refer to such an event as a codeword erasure. Onthe other hand, once K identifier sequences have been read (for Npossible sequences that represent a codeword) during sequencing, thesequencing process can stop, which can decrease the amount of sequencingtime and improve efficiency needed to interpret the codeword. In someexamples, if more than K identifier sequences are read for N possiblesequences that represent a codeword, then the codeword may beinterpreted from the K identifier sequences with the highest copynumbers. In some examples, all combinations of K identifier sequencesfrom the observed >K sequences may be considered to determine a morelimited set of possible codeword values. The correct value may bedetermined in further downstream processing, for example, with hashing.

One way to improve efficiency in reading information from DNA involvesusing a data structure to hold the location of data blocks of datastring. For example, a large data string may be separated and storedinto two or more containers. To determine which container containsinformation a user wants to access, the system may access a B-tree ortrie structure that holds the location (e.g., container number orplacement). This allows a user to access the information he or she islooking for in an expedient manner—rather than reading the informationin each of the containers containing the data string. Further, theinformation a user wants to access may only comprise a plurality ofidentifiers that is smaller than the total number of identifierscontained in a container. In such instances, it would be more efficientand costly to access and read only a small subset of possibleidentifiers comprising the target plurality rather than the entire spaceof possible identifiers that exist in the container. So the locationinformation contained in the B-tree or trie structure may be furtherconfigured to contain information about the target plurality ofidentifiers in addition to the container.

The systems and methods described herein thus provide severalopportunities to decrease the cost and increase the throughput ofwriting information into nucleic acid molecules. First, a set ofcomponents can be reused and recombined to write new packets of digitalinformation. The expensive requirement to use base-by-base synthesis foreach new write job is thus replaced by a one-time base-by-base synthesiscost that may be amortized over several write jobs (e.g., 224 30-baseoligos at 10-μmol scale to write 860 terabit packets). Second, theencoded information is de-coupled from the sequences of DNA components,enabling the use of a large sequence design space that may be optimizedfor write, store, copy, query, and read operations. Third, the nucleicacid molecule encoding schemes described herein comprise enhanced errorcorrection and provide optimized operation speed.

The following description starts with an overview of encoding data innucleic acid molecules, followed by a description of writing andarchival systems configured to print and store encoded nucleic acidmolecules as described in relation to FIGS. 1-5. The present disclosuredescribes various encoding methods in relation to FIGS. 6-11, includingschemes designed for error protection, efficient encoding, and “weightminimization”. The description then describes decoding systems andmethods in FIGS. 12-15. The description introduces data structures thatcan be used in the retrieval of specific information from nucleic acidmolecules in FIG. 18. FIG. 16 shows an overview of archival operationsand FIG. 17 shows a system diagram of writing data to nucleic acidmolecules.

Writing information to nucleic acid molecules using the methodsdescribed herein involve encoding a string of symbols as identifiersequences, where the position and value of each symbol is represented byan identifier sequence. In some implementations, each identifiermolecule is comprised of ligated premade DNA component molecules thatare ordered based on defined layers. Within each layer, several uniqueDNA component sequences can be selected to make an identifier sequence.The one-to-one mapping of a symbol to its corresponding identifiersequence is established by an identifier order, which is an efficientlycomputed function of its components. As a specific example, the set ofavailable identifier sequences may include 15 layers, 14 layers of whicheach contain six unique DNA component sequences. The 15th layer may be amultiplex layer comprising 28 DNA component sequences (rather than six)which will also be incorporated. Thus, each identifier may contain 15components (one component in each layer) in the full-length identifiernucleic acid molecule. During the writing process, the componentmolecules are assembled together in reaction compartments to formidentifier molecules. In some implementations, multiple components fromonly the “multiplex layer” will be combined into the same reactioncompartment.

As an example, to write one terabyte in 86400 seconds (24 hours),approximately 8E+11 identifier molecules may need to be assembled(assuming 10 bits of information encoded per identifier), orapproximately 5.7E+10 droplet reaction compartments. Each reaction mayassemble fourteen identifiers from a possible set of 28 identifiers.Fourteen components (one from each of the 14 layers each with sixpossible components) specify and assemble the “base” of the identifiers.A remaining fourteen components out of 28 possible components from themultiplex layer specify which fourteen identifiers (out of 28possibilities) will be assembled. Thus, each reaction compartment mayneed 28 DNA components, plus ligase or other reaction mix.

The methods described herein may be implemented using a writing system,as described below. The writing system may be a printer-finisher systemsuch as that described in U.S. application Ser. No. 16/414,752 filed May16, 2019, entitled Printer-Finisher System for Data Storage in DNA,which is hereby incorporated by reference. The writer system maydispense DNA components at discrete locations (e.g., reactioncompartments) on a substrate, dispense ligation master mix, provideoptimal conditions for the ligation reaction, and pool all of the DNAidentifiers that comprise a library. The writing system may comprisefour modular components a base instrument, a print engine, an incubator,and a pooling sub-system, as described below in relation to FIGS. 2-5.

The writing systems described herein may execute high-throughput,parallelized printing of ligation reactions for constructingidentifiers. Reactions may be carried out in picoliter (pL)-scaledroplets printed onto flexible sheets (also referred to as webbing orsubstrates) moving over rollers. The writing systems may incorporatetechnologies such as digital inkjet printing and web handling, usingsuitable off-the-shelf print heads, drivers, and machine infrastructure.The systems and methods described herein include optimization of factorssuch as web speed, print head dispense speed, droplet size, and ligationchemistry to achieve storage capacity and write throughput. To this end,and to ensure data tolerance to potential chemistry and hardware errors,the systems and methods described herein include configurations toencode the data and develop printing instructions, includingspecifications for how to partition DNA component sequences into layersand how many identifier molecules to construct in each printed reaction.For example, such configurations may include computer systems thatcommunicate with the writing system and track its performance.

FIG. 1 shows a base module 102 of a writing system configured to executemethods described herein. Base module 102 contains the unwind/rewindcomponents that move webbing 104 through the writing system, such thatcomponents may deposited thereon. Webbing 104 (also referred to as asubstrate) is a material on to which droplet will be dispensed to formdroplet reaction compartments. For example, the webbing may be a lowbinding plastic like polyethylene terephthalate (PET) or polypropylene.Base module 102 is a reel-to-reel machine. Base module 102 may, forexample, be the Werosys Compact system that was developed for theresearch and label manufacturing industries.

The writing system also includes a print engine. The two main componentsof the print engine are the ink management system and print heads fordroplet dispensing. The ink management system includes a vacuum pump,valving/tubing, and on-board software/electronics for local control ofthe vacuum pressure in the headspace above the liquid. For example, theink management system may be a Megnajet system. The ink reservoir can belocated up to 1 m away and may use a Meteor 4-color controller card.

FIG. 2A shows a print head mounting rack 200. Rack 200 holds up to sixprint heads in print head holding spots 202-204. Rack 200 is aninterface between the print heads used to deposit components onto thewebbing and the webbing passing through the print engine. Rack 200 holdsthe print heads close the webbing. For example, the print heads may beheld approximately 0.5 mm, 1 mm, 2 mm, or 3 mm above the web. Rack 200holds the print heads at a cant to appropriately line up print headnozzles for over-printing in reaction compartments because certain printheads have a misaligned nozzle arrangement that limits our ability tooverprint droplets. The cant angle is a slight rotation from the normalvector of the nozzle plate so that the nozzles align to over-printdroplets. The cant angle may be, for example, 1 degree, 2 degrees, 4degrees, 8 degrees, 10 degrees, 20 degrees, or any suitable angle. Toachieve an overprint of, for example, four different nozzle rows, theprint head may rotated at an angle of 8.7°. The accuracy of dropletdispensing is driven by the desired spacing, the diameter of a dropleton the web, which is dependent on the contact angle, and by therepeatability of dispensing. These parameters can be met with availablehardware components but may need some customization during development.

FIG. 2B shows four rows of print head nozzles 212, 214, 216, 218. Eachof rows 212, 214, 216, 218 may dispense a different component. Substrate222 (which extends diagonally upward and to the right from the linepointed at by arrow 219) is moved linearly under the print head withnozzles 212, 214, 216, 218. Because of the 8.7 degree rotation of theprint head, a coordinate 224 on substrate 222 will pass directly beneathnozzles in rows 212, 214, 216, 218 along line 217 such that each nozzlemay deposit a component on coordinate 224.

The print heads can dispense multiple “colors” per print head (four)which allow for overprinting. The droplet volume dispensed by eachnozzle of the print head may be 1 pL, 2 pL, 3 pL, 7 pL, 10 pL, 20 pL, orany other suitable amount. In some implementations, the volume of thedroplets may be adjusted. Flexibility in droplet volume is helpfulbecause this parameter affects evaporation rate and ligation incubationconditions. Additives may be added to the component inks to facilitatecompatibility with the print heads. For example, solutes like tris maybe added to increase conductivity. As an example, humectants orsurfactants (e.g. glycerol) may be added to improve ejection quality andprint head nozzle lifetime.

In some implementations, the print heads are MEMS(micro-electro-mechanical system) devices. For example, the print headmay be a Ricoh MI-15420 print head. Print heads are selected to avoidthe risk and uncertainty associated with many thermal print heads, whichmay compromise the integrity of DNA identifiers. The print heads arecapable of fast, low volume, aqueous-compatible and drop-addressablepiezoelectric dispensing. The print heads may include a stainless steelnozzle plate.

Nozzle clogging is a common failure mode for print heads. For example, astopped print head is at risk of blockage, drying out, and thus needingrecirculation. For this reason, the writing system allows allow printheads to be moved from the writing system for purging and wiping andthen replaced while maintaining registration.

To help repeatability of printing, the writing system may optimizedroplet morphology, volume, and speed. The solution in the print headsmay comprise water-Tris solution that contains dye for visibility. Forexample, the dye may be bromophenol blue. The solution used in the printheads varies from traditional print head inks in that it has lowviscosity and high surface tension. The solution is essentially waterand will have low viscosity at ˜1 cP, compared to ideal ink of 10-11 cP.Because the solution is essentially water, it will have a high surfacetension at 72 mN/m, compared to ideal ink of 32 mN/m

With optimal waveforms, droplet repeatability may be verified bymeasuring droplet shape, volume and speed. Individual droplet volume maybe verified dispensing millions of drops into a mineral oil vessel andmeasuring the change in mass of the vessel. To avoid liquid evaporation,the droplets may be dispensed into the oil such that the aqueousdroplets submerge. Droplet shape and speed may be measured using a “dropwatch” system using a CCD camera to capture droplet dispensingin-flight.

FIG. 3 shows a diagram of dispensing solutions into reactioncompartments according to identifier sequences constructed from a trie.Each layer of the trie represents a layer of the identifier, and eachedge of each trie layer represents a component within correspondingidentifier layer. The final layer of the trie may represent themultiplex layer of an identifier. String of symbols 300 represents a setof codewords to be stored in DNA identifier nucleic acid molecules. Acodeword is a string of symbols that represents a specific string ofsymbols from a source alphabet, called a source word. A code maps sourcewords to codewords in a process known as encoding. Droplets 304 aredispensed into individual reaction compartments (e.g., compartment 306).String of symbols 300 is encoded by constructing identifiers that arerepresented by the trie paths connecting the root of the tree (notshown) to the leaves of the final (multiplex) layer 302 that point tosymbol values of ‘1’. As shown in FIG. 3 and as will be describedfurther below, particularly in relation to FIG. 11, the codeword's“weight” may be evenly distributed—i.e., string of symbols 300 isdivided such that each string of five bits is encoded in a reactioncompartment, and each string of five bits has exactly three ‘1’ valuesso each compartment receives three components from the multiplex layerto form three identifiers. For example, reaction compartment 306 willcontain identifiers with a unique combination of components from thebase layers (the components that comprise the path of the trie up to themultiplex layer—components 7, B, D, . . . ), and components 0, 2, and 4from the multiplex layer, respectively, as shown in the multiplex layerand as corresponding to the positions of the string of symbols “10101”.For each of the ‘1’ values, the corresponding identifier molecule forthat symbol position (comprised of the components that make up the pathleading to it) will be deposited into the reaction compartment.

After the print heads have deposited components into the reactioncompartments, the reaction compartments are moved from the print engineto the incubator module. The incubator is critical for the ligationreaction because it controls the temperature required for optimalligation efficiency and humidity needed for preventing dropletevaporation. The incubator module uses a series of rollers to keep largeportions of webbing (e.g., 10 m, 20 m, 40 m, 100 m, or any suitablelength) in the chamber for the duration of the ligation reaction. Thenumber and position of the rollers allows changes in incubation time orwebbing speed. While in the incubator module, the concentration ofsolutes within the droplet in the reaction compartment need to remainconstant to retain maximal ligation efficiency. For this reason, theprimary function of the incubator is to maintain a level of humiditythat will minimize volume loss due to evaporation. Factors affecting theevaporation rates of droplets are (1) a humectant (likely to beglycerol) may be required within the ligase liquid, in order to preventfull evaporation of the droplet in a time much shorter (<1 s) than therequired ligation time and (2) the concentration of glycerol within theligase strongly affects the required humidity levels and humiditytolerances.

FIG. 4 shows a pooling sub-system using spray wash 414 and immersion inpooling buffer 408 to remove printed droplets from webbing 416. Thepooling sub-system removes DNA molecules from moving web 416 andtransfers it to a DNA binding column. The webbing 416 passes overrollers 402, 404,406. The DNA molecules are removed from the webbing 416using a combination of two mechanisms (1) spray wash 414 of the movingweb using the pooling buffer and (2) immersion of the moving web intothe pooling buffer 408 within the pooling chamber. In someimplementations, only one of the two mechanisms is used, or themechanisms are used in combination with other DNA molecule removingmeans.

After removal from webbing 416, the DNA molecules are passed through abinding column to collect the full-length DNA identifiers 410. Thecolumn 410 is then removed from the writing system for down-streamprocessing, comprising DNA elution and collection within a suitablevessel for storage.

The systems and methods described herein provide a fully automatableworkflow based around nanopore sequencing to decode molecular data. Theworkflow includes validating a physical DNA storage system, developingPCR-based data access methods, improving nanopore sequencingtechnologies (with altered sample preparation, purposefully designed DNAcomponent sequences, and chemically modified nucleic acids), andoptimizing sequencing systems and workflows for large-scale parallelsequencing on multiple devices. DNA-based information produced using themethods described herein is uniquely suited to retrieval bystrategically optimized nanopore (or electronic channel) sequencingmethods. A key hurdle for nanopore sequencers has been achieving slowenough DNA translocation and narrow enough pores to sequence withsingle-base resolution. The DNA components encoded by the methodsdescribed here may be designed to simultaneously boost sequence signalof each component molecule and increase the discrimination betweencomponent sequences. Together with the option of incorporatingchemically modified bases to enhance signal to noise, these featuresallow nanopore technologies to achieve reproducible TB-scale recovery ofartificial DNA information. The system and methods described hereinprovide for the development of organization and storage systems for DNA,the development of a protocol for accessing a DNA library, themodification of sample preparation protocols for improved readingcapacity of encoded DNA, and the advancement of nanopore technology toincrease reading capacity of sequencing instruments.

The output from the writing process of a string of symbols, as describedabove, is a library of encoded DNA (identifiers) that may requirelong-term storage and infrequent access. The produced pool of encodedDNA may contains hundreds of thousands of molecules of each identifiersequence. In terms of grams, the total amount of material produced maybe in microgram quantities. The pool may be amplified with PCR to ensureenough material exists for redundancy, archiving, and accessing, asdescribed below in relation to FIG. 14.

After amplification, the pool may be allocated into multiple containersand stored in different locations. The pool may be stored in a range ofnucleic acid storage and archival systems. For example, DNA may bestored in Eppendorf tubes, in a freezer, cryo-preserved in liquidnitrogen, or stored in Tris-EDTA. Shelf-life of DNA assessed by readingmaterial subjected to accelerated stability conditions such as differenttemperatures. The systems and methods described herein may include anautomated sample management system that allows for both long-termstorage and random access of stored DNA.

In some implementations, an operating system (OS) may be capable ofcoordinating writing, reading, discoverable querying of archivesscalable to Exabyte sizes, or any combination thereof. Specifically, insome implementations, the OS aims to enable the reading and writing of atree of semantically annotated and indexed blocks via a codec optimizedfor the read/write platform described above. The OS includes atranslation stack that can include an ingest API, as well as modules fororganizing and formatting data for long-term yet granular data queryingand discovery. These aspects of the OS can be broadly suited for anywriting, reading, or access method. Other aspects of the OS can bedesigned to specifically optimize methods for writing, accessing, andreading information. These include modules for compressing anderror-protecting data, as well as modules for configuring and sendingdata to the writing systems described above. Though data written in DNAmolecules with the above methods will be readable with any sequencer,specific reading methods are described below. The OS may also includeautomation software and workflows that mediate the handling of DNA-basedinformation between the writer and reader; for example, by allocatingDNA to, accessing DNA from, and replenishing DNA in a system of storagecontainers capable of supporting an Exabyte of information.

FIG. 5 shows an archival information system for the OS. The centralmodule comprises ingestion, data management, access, and archivalstorage modules. The data management and archival storage modulescommunicate with the ingestion and access modules. Descriptiveinformation is passed from the ingestion module to the data managementmodule. Descriptive information is then passed from the data managementmodule to the access module. Archival information package is passed fromthe ingestion module to the archival storage module and then to theaccess module. The central module takes in information from a producer,such as a submission information package, via the ingestion module. Thecentral module also communications with the consumer, via the accessmodule, by fielding queries and sending responses. For example, thequeries and responses may be held in a dissemination informationpackage. The data management and archival storage units also interactwith the preservation planning and administration modules.

FIG. 6 shows a layered organization of the capabilities managed by theOS organized into seven functional layers. Each layer draws on theservices offered by the layer below. The seven layers translate into sixareas of development involving design and construction of:

(1) Codec: an encoder/decoder pipeline with writer-specificoptimizations

(2) Chemistry Interface: a translator from bit operations to chemicaloperations

(3) Automation Interface: interfaces and translators to automationdevices

(4) Block Abstraction: a block-based interface & supporting core datastructures

(5) Search & Indexing: infrastructure for semantic annotation andindexing

(6) Archival Application: an archival application demonstrating the OS

Benefits of the encoding schemes and OS described herein include theability to select an encoding scheme optimized for writing speed,writing cost, reading cost, or access cost; the ability to optimize themapping of index data to blocks to minimize decoded footprint; theability to manipulate information at all scales from large blocks tosingle bits and model data structures natively; and tight integrationwith current archival standards and practices enabling archival,querying, and reasoning over data and relationships.

The codec functions as the encoder/decoder for information. Becauselayers above need it and layers below cannot be meaningfully testedwithout it, the proper operation of the codec is highly important. Thecodec receives a source bit stream and is charged with translating itinto a form suitable for writing using chemical methods. As shown inFIG. 6, the Codec includes three layers: a fixity layer, a redundancylayer, and a combinatorial layer that handle the encoding process.

In the fixity layer, the source bit stream is divided into packets,where all packets are of a fixed size. Packets may be processedindependently and serve as a unit for parallel processing. Packets arecomposed of one or more blocks. A block is the smallest unit ofallocation in the archive, and the archive's combinatorial space isdivided into a series of contiguous strings of bits called blocks. Thefixity layer is responsible for computing a block hash using a standardcryptographic hashing algorithm such as MD5, SHA-224, SHA-256, SHA-384,SHA-512, SHA-512/224, or SHA-512/256 and this hash is included in aparent block. When a block is decoded, its integrity may be checked byre-computing its hash and checking it via the parent block.

In the redundancy layer, the hashed block is passed on to the redundancylayer where up to two, three, or more error protection techniques areapplied. Because the susceptibility to noise of certain writing systemsmay be unknown, a high redundancy convolution code may be used. Errorscaused during writing may be primarily of two types: (1) due to amissing identifier, for example because of deteriorating print headnozzles or low efficiency assembly reactions, or (2) due to assembly ofunintended identifiers, for example because of dispense splatter orcontamination among adjacent reactions. A writing system's imaging-basedquality control methods may mitigate errors due to print head cloggingand missing identifiers. To correct errors, a block is divided intoslices (e.g., 223 bytes long in a typical configuration) and aReed-Solomon code using an arithmetic field of 255 symbols is computedfor each slice, resulting in error protection bytes (e.g., 32) capableof correcting byte-errors (e.g., 16 bytes) (where each byte in error mayhave any number of bit errors). These error protection parameters areconfigurable, are written to the archive, and are configured totolerate, for example, a writing system error rate of 10′ errors percodeword. As defined above, codeword is a string of symbols thatrepresents a specific string of symbols from a source alphabet, called asource word. A code maps source words to codewords during the processknown as encoding.

Assuming a scheme where a source word comprises three source bytes, aprotected slice of 255 bytes will map to 255/3=85 codewords. Assumingindependent errors, the probability that more than 16 bytes will be inerror is the probability that more than five codewords will be inerrors, which is approximately 4.3×10¹⁶. By changing the field size orthe error protection bytes computed, this probability can be lowered asneeded. A writing system with precision printing heads, such as thatdescribed above, may be able to comply with this expected error rate,but the codec is capable of handling higher protection rates if needed,albeit at a higher computing cost. Additionally, a larger field (e.g.65,535) could confer higher protection. To mitigate the impact ofunintended identifier molecules, the redundancy layer may also introducean optional interleaver that permutes the order of the bits so thatsource bits protected by the same set of error protection bytes do notend up in adjacent reaction compartments and thus do not becomesusceptible to larger burst errors than may be correctible.

Symbols, such as the error-protected symbols formed from the methodsdescribed in relation to FIGS. 8-9, may be mapped from source wordscomposed of source symbols (e.g., a series of bits) to codewords from anumber of combinatorial methods for encoding information in nucleic acidlibraries. In some implementations, this encoding is performed ororchestrated by the codec. An example of a particular encoding scheme isshown in FIG. 7. FIG. 8 shows a system diagram of a Layered CartesianProduct combinatorial constructor (LCPCC) for designing and orderingidentifiers. The product constructor has three layers (M=3) and acomponent library of eight component sequences (C=8). A combinatorialpartition scheme with {3,3,2} component sequences per layer is shown.The space of all possible identifier sequences forms a combinatorialspace. As will be described in further detail below in relation to FIG.10, the total number of combinatorial objects constructible from thecomponent library, which may be referred to as the span of acombinatorial scheme, determines the length of the bit stream writableto a single pool of identifiers. The span of this particular scheme is18. The combinatorial objects are ordered in the combinatorial spacelexicographically by extending a ranking on the component sequences tothe identifiers constructed from them. This ordering information isimplicit in the identifier, identifies its position in the combinatorialspace, and may be used to identify the position of the symbol encoded bythe identifier in the source symbol stream. For example, the LCPCC maybe used to encode a binary alphabet, and define the symbol encoded by aconstructed identifier to be “1.” The “0” symbol may be represented bynot constructing the corresponding identifier. A source bit stream maybe encoded by constructing a specific set of identifiers (i.e., anidentifier library) unique to that bit stream.

FIGS. 8-9 show flowcharts 800, 900 for storing digital information intonucleic acids with error protection. At step 802, information isreceived as a string of symbols of length L. As described above, thesymbols may be bits, bytes, a bit string of any length, alphanumericcharacters, a character string of any length or any other suitablesymbol. In some implementations, the string of symbols is converted intoa bit stream. For example, the string of symbols may consist of sixsymbols “LETTER”. The string of alphanumeric characters “LETTER” may beconverted to binary, resulting in 48 bits (“01001100 01000101 0101010001010100 01000101 01010010”). In this example, L would be equal to 48.In some implementations, the information in the string of symbols isreceived separately—i.e., symbols may be received individually or anycombination. The symbols or groups of symbols may then be concatenatedor otherwise combined to form a string of symbols. For example, tenblocks of 8 bits may be received individually and then concatenatedtogether to form a string of symbols 80 bits long.

Flowchart 800 includes three stages of encoding the receivedinformation: (1) hashing, as explained in relation to steps 804-808; (2)adding error protection symbols, as explained in relation to steps810-814; and (3) determining codewords, as explained in relation tosteps 816-820. While FIG. 8 displays all three of these stages, thestages may be performed separately or in any combination thereof. Forexample, steps 804-814 (hashing and adding error protection symbols) maybe bypassed, such that flowchart 800 proceeds from step 802 directly tostep 816 (the start of the codeword stage). The stages may be performedin any order.

The hashing stage begins at step 804, where the string of symbols isseparated into blocks. In some implementations, each block is of thesame length B, where B is equal to L (the length of the string ofsymbols) divided by the number of blocks. As an example, the string ofsymbols may be 1,000 bits. The 1,000 bits may be separated into anylength of blocks, such as five blocks each consisting of 200 bits; 100blocks each consisting of 10 bits; 10 blocks each consisting of 100bits, or any such combination. In some implementations, the blocks arenot of equal length. For example, for a string of 1,000 bits, block₁ mayconsist of 500 bits; block₂ of 100 bits; block₃ of 300 bits; and block₄of 100 bits. In some embodiments, blocks may be padded with arbitrarysymbols to reach a target length.

At step 806, a hash of length H is computed for each block. In someimplementations, the hash is computed using one of MD5, SHA-224,SHA-256, SHA-384, SHA-512, SHA-512/224, or SHA-512/256. Each computedhash is appended to the corresponding block to form a hashed block. Thisallows string of symbols and the hashes to be stored together in nucleicacids. An alternative implementation that includes storing the hashesseparately from the string of symbols is described below in relation toFIG. 9. If each block is of length B, after appending the hash, thehashed blocks are of length H plus B. For example, the string of symbolsmay consist 1,000 bits that are then separated into ten blocks of 100bits each (B=100). The hash of each block may be 10 bits long (H=10).After appending, the hashed blocks then consist of 110 bits (theoriginal 100 bits plus the 10-bit hash).

At step 808, the hashed blocks are concatenated to form a second stringof symbols of length L2. In the example above, where each hashed blockof the ten hashed blocks comprises 110 bits, the string of symbols wouldbe equal to 1,100 bits (the original 1,000 bits received in step 802plus 100 hash bits computed in step 806).

At step 810, the second string of symbols is separated into slices. Insome implementations, each slice is of the same length S, where S isequal to L2 (the length of the second string of symbols formed in step808 from the hashed blocks) divided by the number of slices. As anexample, the second string of symbols may consist of 1,100 bits. The1,100 bits may be separated into any length of slices, such as tenslices each consisting of 110 bits; one hundred slices each consistingof 11 bits; five slices of 220 bits, or any such combination. In someimplementations, the slices are not of equal length. For example, for astring of 1,100 bits, slice₁ may consist of 500 bits; slice₂ of 100bits; slice₃ of 300 bits; and slice₄ of 200 bits. In someimplementations, the hashing stage (steps 804-808) is bypassed. Thus,the second string of symbols references in step 810 would be equal tothe string of symbols received in step 802. In some implementations, theblocks are never concatenated back together to form L2, but rather eachblock is processed into slices separately.

At step 812, error protection symbols are computed for each slice. Anynumber of error protection symbols may be computed for each slice. Atstep 812, the error protection symbols are appended to the slice forwhich they were computed, thereby forming error-protected slices. Insome implementations, the same number P of error protection symbols arecomputed for each slice, such that the each error-protected slice is Splus P bits long. For example, if the second string consists ofconcatenated blocks that are each 1,100 bytes (1000 source bytes plus a100-byte hash), they can each be divided into five slices consisting of220 bytes. Then 40 bytes of error protection can appended to each sliceresulting in error-protected slices consisting of 260 bytes each.

In some implementations, the error protection symbols are determinedusing a Reed-Solomon code. Reed-Solomon codes are block-based errorcorrecting codes. If the P error protection symbols (or bytes) arecomputed using a Reed-Solomon code,

$\frac{P}{2}$

erroneous symbols (or bytes) can be tolerated in a protected slice. Forexample, if P is equal to 40 bytes for a 260-byte protected slice, 20 ofthe 260 bytes may be incorrect without negatively affecting theprocessing of those 260 bytes. If the P error protection bytes arecomputed using a Reed-Solomon code, P erased bytes can be tolerated. Forexample, if P is equal to 40 bytes for a 260-byte protected slice, 40 ofthe 260 bytes may be erased without negatively affecting the processingof those 260 bytes.

At step 814, the error-protected slices are concatenated to form a thirdstring of symbols having length L3. In the example above, where eacherror-protected slice of the five error-protected slices per blockcomprises 260 bytes, the third string of symbols would consist of 1,300bytes per block (the original 1,000 bytes received in step 802 plus 100hash bytes computed in step 806 plus 200 error protection bytes totaldetermined in step 812). In some implementations, flowchart 800 proceedsfrom step 808 to step 816, bypassing the error protection stage (steps810-814). Thus, the third string of symbols references in step 814 wouldbe equal to the second string of symbols formed in step 808. In someimplementations, both the hashing and error protection stages arebypassed, such that flowchart 800 proceeds from step 802 directly tostep 816. In this case, the third string of symbols would be equal tothe string of symbols received in step 802. In some implementations, thethird string of symbols is computed and processed separately for eachblock.

At step 816, the third string is separated into a plurality of words,each word having length W. For example each word may be eight bits long.At step 818, a codeword is determined for each word using at least onecodebook. In some implementations, each codeword is an exact match ofthe respective word (i.e., nothing changes between the third and fourthstrings of symbols). In some implementations, however, the codewords maybe different from their respective words. For example, the codewords canbe a different length than the words.

Codewords may be optimized for chemical and instrument conditions duringencoding or decoding. As described above, the presence of an identifiermay indicate a ‘1’ in a certain symbol position, while the absence of anidentifier for that position would indicate a ‘0’. In someimplementations, determining the codewords comprises applying a uniformweight code (e.g., as described in relation to FIG. 11) to the thirdstring of symbols to ensure every codeword has the same number of ‘1’s(i.e., identifiers to be constructed in step 824). Thus, for the exampleabove with W=8, a codeword must be chosen that can encode eight bits.This effectively adds additional bits so that each codeword can have anequal “weight” (number of identifiers to be constructed).

As described in relation to FIG. 7, the codewords may be determined froma combinatorial space in an NchooseK scheme. In an Nchoosek scheme, forevery N ordered identifiers, k identifiers are constructed. For example,in an 11choose4 scheme, for every 11 identifiers, exactly four areconstructed. The representative codeword would have length N=11 bits andhave weight k=4. An 11choose4 scheme provides enough bits to encode 8bits in each codeword because Log₂(11choose4)>8.

At step 820, a fourth string of symbols having length L4 is formed byconcatenating the codewords. The fourth string of symbols will comprise

$\frac{L\; 3*N}{W}$

symbols. For example, for a string of 1300 bytes per block (e.g., thethird string of symbols formed in step 814) if each word is 8 bits andan 11choose4 scheme is used, L4 would equal 1787.5 bytes per block, or14300 bits if each byte is eight bits. In some embodiments, the fourthstring of symbols is computed and processed separately for each block.

At step 822, each symbol in the fourth string is mapped to an individualidentifier sequence. The mapping step 822 produces a scheme for printingthe digital information into nucleic acids with error protection. Anindividual identifier nucleic acid molecule of the plurality ofidentifier nucleic acid molecules corresponds to an individual symbol inthe fourth string of symbols. An individual identifier comprises acorresponding plurality of components, wherein each component in theplurality of components comprises a distinct nucleic acid sequence. Forexample, the components may be selected from M layers as describedabove.

At step 824, the individual identifier molecules are constructed bydepositing (or co-locating) and assembling corresponding components. Forexample, the printer/finisher system described above in relation toFIGS. 1-5 may be used to construct individual identifiers by depositingand assembling corresponding components in a compartment. In someimplementations, dispensing, using a plurality of print heads, aplurality of solutions comprising a plurality of components onto acoordinate on a substrate. A reaction mix may be dispensed onto thecoordinate on the substrate to physically link the plurality ofcomponents, provide a condition necessary to physically link theplurality of components, or both.

Based on the codeword stage, a set of printer instructions may bedeveloped that are then sent to a printer-finisher system. The printerinstructions may be configured to reduce the possibility of printingerrors or increase printing efficiency. For example, the codeword stagemay be designed to distribute the identifiers such that each compartmentin the plurality of compartments contains the same number of copies ofeach identifier nucleic acid sequence to within a statistical certainty,thus providing uniform abundance of identifiers across compartments. Toprovide additional error protection, in some implementations, codewordsare permuted or interleaved (with respect to one another) before beingsent to the writing instrument, such that identifier nucleic acidmolecules that represent adjacent symbols in the string of symbols arenot constructed in adjacent compartments. This reduces the chance thatburst errors in the writing instrument results in uncorrectable errorsor erasures. For example, this reduces the chances that printingmistakes may cause undetectable errors due to streaks of printing ontothe wrong coordinate or bleeding between compartments. Alternatively,the error protection may be computed on disparate symbols rather thanadjacent symbols to reduce the chance that burst errors in the writinginstruments results in uncorrectable errors or erasures

At step 826, the individual identifiers are collected in a pool. Forexample, a pool can hold hundreds of identifiers corresponding tohundreds of symbols encoded in steps 802-822. In some implementations, apresence or absence of an identifier in the pool is representative ofthe symbol value of the corresponding respective symbol position withinthe string of symbols.

Flowchart 900 follows the same steps with the exception of storing thehashes rather than appending them. Steps 902, 904, 908, 910, 912, 914,916, 918, 920, 922, 924, and 926 are equivalent to steps 802, 804, 808,810, 812, 814, 816, 818, 820, 822, 824, and 826, respectively. In step906, hashes are computed for each block but not appended; rather, thehashes are stored separately. For example, the hashes may be stored on ahard drive in order for the hashes to be accessed faster or more easilythan the blocks in nucleic acids. The hashes could be stored in nucleicacid molecules, a magnetic storage device, a flash memory device, cloudstorage, or any other suitable location.

When encoding a string of symbols, the number of distinct identifiersequences that can be constructed depend on the parameters of theencoding scheme used and the string of symbols to be encoded. For agiven string of symbols, it may be advantageous to generate an optimizedscheme that minimizes key resources (e.g., the number of layers orcomponents used to build the identifiers). A set of C components may bepartitioned in B(C) distinct ways, where B(C) is the C^(th) Bell number,and increases factorially with C. If the L layers contain c₁, c₂, . . ., c_(L) components respectively, then the total number of distinctidentifiers constructible is Π_(i=1) ^(L)c_(i), with Σ_(i=1)^(L)c_(i)=C. The total number of combinatorial objects constructiblefrom the component library, which may be referred to as the span of acombinatorial scheme (as noted in relation to FIG. 7), determines thelength of the bit stream writable to a single pool of identifiers.Therefore, for a given bit stream length and component library size, apartition scheme with a span large enough to encode the bit stream,while minimizing the number of layers, may be beneficial. Eachadditional layer imposes additional efficiency and time constraints onthe chemistry; therefore a partition scheme with fewer layers ispreferable. An example of a partition scheme to minimize layers isdescribed below in relation to FIG. 10. A branch-and-bound search overthe space of partitions possible from the prime factorization of the bitstream length.

The codec or any encoding system may use several strategies to compute aset of multiplexable reactions. First, a strategy borrowed frommulti-valued logic synthesis may treat all or parts of a string ofsymbols, such as a bit stream, as a Boolean function and attempt toextract a minimal representation of the function using heuristics. Stateof the art logic synthesis tools have been shown to be able to handlefunctions with ˜10⁶ row truth tables. If the source stream is alreadyentropy compressed, then this approach may fail because succinctrepresentations may be difficult to find. For compressed streams, alocal greedy approach is to divide the stream into reaction words of Zadjacent identifier sequences, and use a component partition scheme thathas at least Z component sequences in the multiplexing layer. Thisforces Z identifiers to share the same prefix, and facilitatesassembling them in a single reaction compartment. (For example, Z=2 inFIG. 7.) Inversely, another performance measure of interest is thenumber of bits encoded per reaction. Minimizing reaction compartmentsincreases the number of symbols written in a single reaction, thusminimizing the write time and the total substrate length needed by thewriting system to write a given string of symbols.

Another key resource is the number of identifiers that can beconstructed to encode a source bit. By default, an LCPCC scheme encodeseach symbol position of a string of symbols with a unique identifiersequence. If the string of symbols is a bitsteam, where a ‘1’ isindicated by the presence of an identifier and a ‘0’ is represented byits absence, the number of identifiers that can be assembled to writethe bit stream is proportional to the number of ‘1’ bit values in thesource bit stream. Unlike in silico compression where bit stream lengthis a key measure, here it is the weight of the bit stream—the number of“1” bit values—that may define the writing time or reaction compartmentsneeded.

Assembling identifiers (e.g., the identifiers described in step 1008 ofFIG. 10) may require performing a chemical reaction in a compartmentwhere all the necessary components and reagents are collocated at thetime of the reaction. The number of such compartments needed is acritical resource that may be minimized. One strategy to minimizingreaction compartment count is to execute multiple reactions in eachcompartment. Not all reactions, however, may be mutually combinable. TheLCPCC (described above in relation to FIG. 7) generates a combinatorialspace such that adjacent identifier sequences share a common prefix ofcomponent sequences. For the example in FIG. 7, identifier sequences 0and 1 share a common component sequence prefix—identifier sequence 0 hascomponent sequences 0, 3, 6 and identifier sequence 1 has componentsequences 0, 3, 7. This implies that the construction of identifiers 0and 1 may be executed in a single reaction compartment in which fourcomponents are collocated: 0, 3, 6, and 7, because components 6 and 7,by construction, are mutually inert. This strategy of executing multiplereactions in a single compartment may be referred to as multiplexing,and the layer from which multiple components are taken, the multiplexinglayer.

FIG. 10 shows a flowchart 1000 outlining the steps for encoding digitalinformation into nucleic acids with a partition scheme. The partitionscheme may be designed with the intention of encoding the digitalinformation in nucleic acids under restraints, such as writing hardwareconfigurations (e.g., the number of inks available in a printer).Flowchart 1000 begins at step 1002. Like steps 802 and 902 of FIGS. 8-9described above, at step 1002 digital information is received as astring of symbols having length L. In some implementations, anadditional step may be incorporated in flowchart 1000 to translate thestring of symbols to a string of bits of length B.

In order to encode within the given restraints, at step 1004 a partitionscheme is determined. The partition scheme defines a set of rules toencode the string of symbols using a set of C distinct componentsequences. Specifically, the partition scheme defines a number of Mlayers within which to arrange the C distinct component sequences, anddefines component sequences numbers in each layer, such that there arec_(i) component sequences in the i^(th) layer. In some implementations,the number of component sequences in each layer is non-uniform (i.e., c₁is not equal to c₂, etc.). The number of layers and number of componentsequences may be configured to minimize the number of layers necessaryto encode the string of symbols, thereby simplifying the chemistry offorming identifier molecules while maintaining enough identifiersequence possibilities to encode the entirety of the digitalinformation. To ensure enough identifier sequence possibilities toencode the string of symbols, a product of the component sequencenumbers c_(i) (Π_(i=1) ^(L)c_(i)) must be greater than or equal to thelength (as measured in bits) of the string of symbols and a sum of thecomponent sequence numbers c_(i) (Σ_(i=1) ^(L)c_(i)) must be less thanor equal to the number C of distinct component sequences. In someimplementations, the identifiers are representative of a subset of acombinatorial space of possible identifier sequences, each including onecomponent from each of the M layers. As a simple example, if L equals1,000 bits (e.g., 1,000 bits in a bit stream received in step 1002) andC equals 70 (e.g., 70 printer inks available to be printed), threelayers (M=3) with 10 component sequences per layer could be used toencode the data. However, to best capitalize on the available 70component sequences, it may be more efficient to encode the data usingtwo layers (M=2), with 50 component sequences in the first layer and 20component sequences in the second layer.

In some implementations, if the string of symbols has been translated toa string of symbols of length B, the product of the component sequencenumbers c_(i) must be greater than or equal to the length of the stringof symbols of length B, converted to bits. For example, if thetranslated string of symbols is “LETTER”, B equals 6 but the equivalentstring of bits consists of 48 bits (B equals 48) if each character isencoded by 8 bits. Thus, the number of M layers and C componentsequences necessary to encode “LETTER” must be such that Π_(i=1)^(L)c_(i)≥48.

At step 1006, a first identifier is formed, for example with aprinter-finisher system, by (i) selecting one component from each of theM layers, (ii) depositing the M selected components into a compartment,and (iii) physically assembling the selected components. In someimplementations, the selected components are assembled by ligation. Insome examples, the M layers are associated with different prioritylevels. For example, the first layer may have a highest priority and thesecond layer may have a second highest priority.

At step 1008, additional identifiers are formed. The additionalidentifiers correspond to respective symbol positions in the string ofsymbols that represents the digital information to be encoded. Eachsymbol position within the string of symbols may have a correspondingdifferent identifier. Once the necessary amount of identifiers areformed, the identifiers are collected in a pool in step 1010.

FIG. 11 demonstrates a uniform weight code to translate each word into acodeword with fixed weight. Uniform weight coding can improve decodingand simplify a writing system's configuration. One approach to this isto construct a complete bipartite graph of all possible source words andtheir mapping to all possible codewords. Each edge of the completebipartite graph is weighted by the number of ‘1’ bit values introducedby the codeword. By choosing a minimal weight matching, a problem forwhich linear programming-based polynomial time algorithms exist, onecould find a mapping that minimizes the bit stream weight, effectively“compressing” the total number of identifier sequences needed to writeit. Such a code may be referred to as a weight minimizing code. Thenumber of “1” bit values may be minimized by recoding the source bitstream using longer codewords. In FIG. 11, the minimum weight of acodeword of length five necessary to encode a word of three bits, isweight two. However, because three bit words will on average have aweight of 1.5, this codeword scheme, though minimal in weight forcodewords of length 5, actually increases the total weight of themessage. If, for example, the codewords were extended to length eight,then there could be a codeword weight of one to encode three bits. Inthis example, the overall weight of the message would be lessened.Weight minimizing techniques may be used to reduce the number ofidentifier sequences needed per source bit.

Reading an identifier library by sequencing involves sampling from adistribution of multiple copies (multiple nucleic acid molecules) ofdistinct identifier sequences. Non-uniformities in enrichment ofidentifiers can make sampling lower copy identifiers difficult, pushingthe need for larger samples. Because the writing systems describedherein assemble multiple identifiers in reaction compartments viamultiplexing, and because the number of identifier sequences in eachreaction compartment is defined by the source bit stream, the enrichmentof each identifier in the final library could vary. One approach tomitigating this problem is to recode the source bit stream using auniform weight code, one in which every codeword contains a fixedconstant number of “1” values, as shown in FIG. 11. Consequently, eachreaction compartment assembles a fixed number of identifiers and thusthe variance in enrichment is minimized without modification to thewriting system. Moreover, by choosing the codeword length judiciously, auniform weight code could also minimize the weight of the bit stream.For example, the set of 37.4×10⁶ 28-bit codewords of a fixed weight of13 can encode all 25-bit source words, yielding 25/13=1.92bits/identifier. As another example, the set of 64.5×10⁶ 32-bitcodewords of a fixed weight of 10 can encode all 25-bit source words,yielding 25/10=2.5 bits/identifier.

An additional benefit of uniform weight coding is that when a library isread, each codeword decoded is expected to contain a known fixed numberof “1” values which enables the use of more robust decoding techniques.Pushing this idea to the extreme, a long codeword, for example 1024bits, could span multiple reactions, yet may require assembling only asingle identifier encoding 10 bits; this can lead to extreme “weightcompression” enabling high encoding rates due to the need to constructvery few identifiers, and high decoding rates due to higher bits encodedper identifier.

Because the recoding techniques described above are applied in thecombinatorial layer after classical redundancy bytes have been computed,they can have an impact on the error protection performance. Forexample, when a 25-bit source word is mapped to a 28-bit codeword ofuniform weight 13, the mapping may not be isometric: a 1-codeword errorcan now cause a multi-byte error in the source word. Extreme weightminimization may also affect the SNR (signal-to-noise ratio) of anencoded bit because the minimum distance of the code is reduced. Toinvestigate and remedy these issues, weight minimizing uniform weightcodes may be used that include source words may be embedded intocodewords near-isometrically. This may result in the use of longercodewords, but also offer better error performance. To generate anencoding scheme that co-optimizes against all these constraints, toolsmay minimize layers, maximize span, minimize reaction compartments,minimize weight, and find a code that uses constant weight codewordsthat preserve error protection performance.

A throughput of roughly 1 Mb/s may be achievable per CPU-thread for theencoder as described above. As an example, a rate of 93 Mb/s (1 TB/day)may be achievable using four instances of 32 CPUs, −10 TB of temporarydisk space, and −3 TB of outgoing bandwidth, which may be amortized over1080 jobs. The cost of producing this encoded information may be roughlyhalved if similar infrastructure were locally connected to the writingsystem, saving the cost of outgoing bandwidth and assuming ingest wasfree. Using GPUs or server-less cloud functions could reduce this costfurther, at the expense of software refactoring and platform dependence.

Recovering a source bit stream from an archive follows a roughly inverseprocess to the one described above. FIG. 12 shows a system diagram withthe basic steps of decoding a set of identifiers. The system obtains apool of the subset of identifiers of interest. The goal is toreconstruct a set of identifier sequences with the highest likelihood tohave produced the sequences observed in an adequate sampling of thepool. Using a simulation model, a sample size estimate is first computedfor the identifier sub-library to be decoded, given a small acceptableprobability of incomplete sampling. Using the compute sample size, theidentifier library is sampled and sequenced to obtain a stream orcollection of observed sequences.

Consider an observed sequence s. From the representation informationstored the archive described above it is known that the sequence comesfrom a LCPCC identifier library with L layers, where the jth componentof layer i contains component sequence c_(ij). Therefore, the observedsequence s is first compared with component sequences c_(1j) for all j.If an exact match is found, then the unmatched suffix of s undergoesthis same process now with i=2. If no exact match is found, then a fastapproximate matching score is computed for any prefix of s and componentsequences c_(1j) using an approximate string matching technique (ASM) oralignment technique, or an n-gram approach. ASM (approximate stringmatching) methods may be evaluated to determine their suitability to“online” matching of streaming sequence data, as is expected from ananopore sequencing device, described below.

For a component sequence of length l_(c), only the variable segment ofthe component sequence need be identified. The variable segment of thecomponent sequence may be as small as 1c/3, unlike bit-by-bit writingschemes that endeavor to decode every base. This process is repeatedwith the unprocessed suffix of s and results in an L-partite graph withvertices weighted by a match score. The top weighted paths correspond tocandidate identifier sequences, and each candidate has a score.Identifier sequences belong to an ordered combinatorial space, so eachcandidate identifier sequence corresponds to a symbol in the encodedstream. Some candidate identifier sequences may contradict the codewordrules; for example, a codeword may be of a fixed weight. Thesecandidates may be eliminated based on low scores or saved as analternative set of candidates. Finally, a path through top rankingcandidates is constructed to obtain a candidate sequence of codewords.This sequence of codewords is then checked against fixity data andcorrected if possible using error correction symbols. In cases ofextreme noise or error, the technique could backtrack and choose analternative path through candidate identifiers to search for the correctsequence of candidates.

Once codewords are obtained, they are mapped back to source words usingan implicit Lehmer codebook to obtain the error-protected source blocks.These blocks are then decoded and checked to verify fixity. If errorsare found, error protection symbols are used to correct them if possibleand the source blocks are recovered. The source blocks are appropriatelyassembled into a source bit stream and handed off to the block layer forquery response assembly, delivery, and caching.

FIG. 13 shows a flowchart 1300 outlining the steps for reading digitalinformation stored in nucleic acid sequences. At step 1302, a pool ofidentifiers is obtained (e.g., via the methods described in relation toFIG. 14). The identifiers in the pool store digital information from astring of symbols of length L. The pool of identifiers corresponds to asubset of identifier sequences in an identifier library that is capableof encoding any string of symbols having length L. Each individualidentifier in the pool corresponds to a symbol value and a symbolposition in the string of symbols. Each individual identifier comprisesa plurality of components and is thus an instance of a specificsequence.

Between steps 1302 and 1304, the identifier may be processed in variousways. In some implementations, the identifier is ligated to a secondidentifier. In some implementations, one strand of the identifier isdegraded. For example, a strand-specific exonuclease may be used toselectively degrade one strand of the identifier.

At step 1304, at least one of the obtained identifiers is read to obtaina read sequence corresponding to a portion of the at least oneidentifier. Step 1304 may be accomplished by any sequencing technique,such as chemical sequencing, chain termination sequencing, shotgunsequencing, bridge PCR sequencing, single-molecule real-time sequencing,ion semiconductor sequencing, pyrosequencing, sequencing by synthesis,combinatorial probe anchor synthesis sequencing, sequencing by ligation,nanopore sequencing, nanochannel sequencing, massively parallelsignature sequencing, Polony sequencing, DNA nanoball sequencing, singlemolecule fluorescent sequencing, tunneling current sequencing,sequencing by hybridization, mass spectrometry sequencing, microfluidicsequencing, transmission electron microscopy sequencing, RNA polymerasesequencing, or in vitro virus sequencing. Sequencing a pool of nucleicacids, identifiers in this case, yields a read sequence for the wholepool; however, it is not known how each identifier of the pool maps tothe read sequence. Sequencing methods are prone to single-base errors,further hindering the matching of identifiers to the read sequence.

In some implementations, step 1304 includes nanopore sequencing. Anelectric field is applied to an electrolytic solution and at least onenanopore channel. In some implementations, the at least one nanoporechannel is formed within a solid-state membrane. In someimplementations, the nanopore channels are formed from alpha-hemolysin(αHL) or Mycobacterium smegmatis porin A (MspA). During nanoporesequencing, the identifier is translocated through the at least onenanopore channel, while impedance across the channel is measured. Eachcomponent in the identifier has a corresponding unique impedancesignature along the length of the component sequence, thus allowing thecomponents in the read sequence to be determined by comparing measuredimpedance values to the unique impedance signature.

In some implementations, when step 1304 includes nanopore sequencing,the applied electric field generates a differential potential greaterthan or equal to 100 mV. This high differential potential enables theidentifier to be passed through the nanopore channels at a relativelyhigh rate. For example, translocation of the identifier may occur at arate great than 1,000 bases per second. In particular, the translocationrate may be 1,000,000 bases per second.

In some implementations, when step 1304 includes nanopore sequencing, anagent is bound to the identifier before translocating. For example, theagent may be a chemical moiety, a protein, an enzyme, a base analogue, aconjugated nucleic acid, a nucleic acid with a hairpin, or a methylgroup. In some implementations, if the agent is a chemical moiety, anenzyme, such as methyltransferase, binds the chemical moiety to the atleast one identifier nucleic acid molecule. In some implementations, ifthe agent is a base analogue and the agent is bound using an enzyme,such as a polymerase, the enzyme binds the base analogue to the at leastone identifier nucleic acid molecule during replication.

The agent is associated with an agent signature that may be used to helpdetermine sequences in the identifier during reading. Binding the agentto the at least one identifier nucleic acid molecule occurs at a knownlocation on a component of the identifier, such that the agent signatureat the known location results in a known shift in impedance value duringtranslocation. The presence of the agent may thus create an exaggerated“profile” for the identifier, thereby increasing the signal-to-noiseratio during reading. This may allow the translocation speed to beincreased while maintaining accuracy during reading. In particular, thepresence of the agent on the at least one identifier may allow for afirst maximum translocation rate that achieves a desired level ofaccuracy that is faster than a second maximum translocation rate thatachieves the desired level of accuracy in the absence of the agent onthe at least one nucleic acid molecule. Another way to increasesignal-to-noise ration during reading includes replicating theidentifier such that it comprises modified bases or base analogues. Thismay done separately or in addition to binding an agent to theidentifier.

Steps 1306, 1308, 1310, and 1312 describe a method of matching the readsequence to a known set of identifier sequences (i.e., the identifierlibrary). In step 1306, the read sequence is used to identify a set ofcandidate identifier sequences from the identifier library that have acomponent sequence that approximates or exactly matches the readsequence. As an example, the read sequence (which may or may notcorrectly match the identifier) may be CAGCTG. The set of candidateidentifier sequences may comprise an exact match (CAGCTG) as well asother potential matches that are similar to the read sequence, such asidentifier sequences that differ by a certain number of bases (e.g., 1,2, 3, 10, 20, 100, etc.). For example, the set of candidate identifiersequences may also include CAGATG, AAGCTA, and CACGTG. For ease ofreference, the “incorrect” nucleotides (i.e., that do not match the readsequence in the example) are underlined.

In some implementations, the identifiers are encoded such that eachidentifier is associated with a reading error tolerance (for example byensuring a minimum hamming or Levenshtein distance between components ofthe same layer). A permissive reading error tolerance may be used toincrease the rate at which the identifier is read. Another way toincrease read speeds includes reading a subset of the identifier. Insome implementations, the identifier includes M components correspondingto M layers (as described above in relation to FIG. 10). In someimplementations, reading the identifier includes reading only N of the Mcomponents where N is less than M. For example, only the first twolayers out of five layers may be read. This can increase how manyidentifiers are read in a given amount of time. This can be helpful whena subset of the data encoded in the pool needs to be accessed. Forexample, if the first layer always indicates a certain meaningful value,certain useful identifiers can be identified by only accessing the firstlayer. Or, for example, if all accessed identifiers have the samecomponents in the first four layers, then those four layers need not beread.

In step 1308, each candidate identifier sequence is assigned a scoreassociated with how similar the component sequence of each candidateidentifier sequence is to the read sequence. The better the candidateidentifier sequence matches the read sequence, the lower (or higher) thescore may be. The scores may be computed in a variety of ways includinga least distance algorithm, a percent match, or any other suitablealgorithm. As an example, for the read sequence CAGCTG, a candidatesequence CAGCTG may have a score of zero, while a candidate sequenceCAGATG may have a score of one because the fourth base of the candidatesequence does not match the read sequence. The score may depend on thenumber of bases that are incorrect and/or the placement of incorrectbases. For example, a candidate with two incorrect nucleotides adjacentone another (CACGTG) may have a lower score than a candidate with twoincorrect nucleotides that are not adjacent (AAGCTA).

The set of scores guides the decision in step 1310 to select one of thecandidate identifier sequences as a potential match to the identifierthat was read (or observed) in step 1304, thereby mitigating the effectof single-base sequencing errors. For example, the candidate sequencewith the lowest score may be selected because it is the closestpotential match to the read sequence. At step 1312, the selectedcandidate identifier sequence is then mapped to a symbol position andsymbol value using the identifier library. In some implementations, ifstep 1304 includes nanopore sequencing and an agent has been bound tothe identifier, determining the sequence in the identifier includescomparing measured impedance values during translocation to the agentsignature.

In some implementations, steps 1306, 1308, 1310, and 1312 are iterateduntil the desired digital information is completely accessed from thepool (or multiple pools) of identifiers. In some implementations, adecoded string of symbols is determined and tested for accuracy.Specifically, a hash of a portion of the decoded string of symbols maybe calculated then compared to a hash associated with a correspondingportion of the string of symbols obtained in step 1302. The hash may bestored as a plurality identifiers in the pool (and subsequently be readvia the steps of FIG. 13 above) as described in relation to FIG. 8, ormay be stored remotely, as described in relation to FIG. 9. The hash maybe calculated using MD5, SHA-224, SHA-256, SHA-384, SHA-512,SHA-512/224, or SHA-512/256 or any other suitable algorithm. A mismatchbetween the read out or original hash and the computed hash indicatesthere was an read error in reading the data—e.g., the informationextracted from the nucleic acid molecules does not match the sourcedata. Based on whether the calculated hash matches the read out originalhash, the portion of the decoded string of symbols may be verified as amatch to the portion of the string of symbols obtained in step 1302. Ifthe hashes do not match (or if it is determined the decoded string doesnot match the obtained string through any other means), a differentcandidate identifier sequence (e.g., of the set of candidate identifiersequences from step 1306) may be selected (e.g., as in step 1310described above). As identifiers are decoded and verified, a computersystem may track this information and use a machine learning techniqueto increase a likelihood that the decoded string of symbols matches thestring of symbols. The error-tolerant method disclosed by FIG. 13 thusset a basis for making unconventional improvements to sequencingtechniques, for example running nanopore sequencing at a substantiallylarge applied voltage, as described above.

In terms of grams, the total amount of material in a given pool may bein microgram quantities. To accurately read the molecules in the pool,it may be amplified with PCR to ensure enough material exists forredundancy, archiving, and accessing. The components on each edge of theidentifiers can be designed to have common primer binding sites so thatentire identifier libraries can be replicated exponentially in one PCRreaction. etc.

Moreover, a nested PCR-based, chemical random access method can be usedto efficiently sub-library of identifiers for reading. FIG. 14illustrates an example of a nested PCR amplification scheme foraccessing a sub-library of identifiers from an archived DNA library. Asub-library may be any group of identifiers that one wishes to access,such as a data block, several data blocks, a single identifier, severalidentifiers, etc. In the first amplification step with (A) primers thatbind components on the edge layers of the identifiers, a group ofidentifiers comprising the desired data block is selected and enriched.This process is repeated with (B) primers that bind components on thenext two layers inward and therefore further reduced the group ofidentifiers to a smaller sample that comprise the desired data block.This process may be repeated until the retrieved (or accessed, orselected) group of identifiers is only or nearly only comprised of allidentifiers that represent the desired data block, thus enabling thedata block to be read back efficiently with sequencing. In the finalround of nested PCR, the identifiers may be simultaneously prepared forsequencing. With this nested approach for amplification, the number andidentity of identifiers accessed is adjusted and the sequencing burdenis reduced. In some implementations, amplification steps are limited toseven cycles or less to reduce amplification bias in the libraries andto maintain uniformity of sequence abundance. Primer combinations may bevalidated with identifiers to demonstrate efficiency and uniformity ofthe amplification process. As described below, this access method may beused in conjunction with data structures to retrieve blocks of data bytheir associated block ID. As an alternative to nested PCR, affinitytagged probes that uniquely bind particular components may be used in anested fashion to access a particular sub-library of identifiers (thatrepresent a data block, for example) for reading.

Reading the identifier nucleic acid molecules in 1304 may beaccomplished via nanopore sequencing. Nanopore sequencing providesadvantages due to size and scalability. Nanopore sequencing involvesapplying an electric field to an electrolytic solution and nanopores.Under the applied voltage, nucleic acid molecules pass through thenanopores, interrupting the flow of the electrolytic solution andcausing a measurable impedance. Each nucleotide can be correlated to aunique impedance value such that a whole sequence corresponding to anucleic acid molecule can be obtained by processing an impedancedataset. The nanopore can be formed by a channel in solid-statesubstrate or by a protein. The protein may be embedded in a lipidmembrane or a solid-state substrate such as metal, metal alloy, andpolymer-based substrates, and common nanopore proteins includealpha-hemolysin (αHL) and Mycobacterium smegmatis porin A (MspA). For apoint of reference, Oxford Nanopore's PromethION system is approximately1.5 square feet in size and is able to sequence 12 Tb (12.0E+12 basepairs) in 48 hours. It is important to note, that because the writingscheme described herein uses premade DNA components that are verified tohave high fidelity, any sequence error is likely only introduced duringsample preparation and sequencing. Further, single base resolution maynot be needed to identify components present in identifiers. For thesereasons, improvements to sequencing speed are enabled by adjustingsample preparation protocols and implementing compression techniques (atleast for digital information not already compressed).

The standard template preparation scheme for Oxford nanopore sequencinginvolves ligation of adapter protein complexes to nucleic acidmolecules. Some adapter proteins act as a hydrophobic tether allowingfor the nucleic acid molecules to target the lipid bilayer reducing thetime nanopores are unoccupied. Another protein, or motor, such asα-hemolysin separates the double-stranded nucleic acid molecules so thata single-strand enters the nanopore. This motor then helps ratchets thesingle-stranded nucleic acid molecules through the nanopore. Thisprotocol is entirely compatible with the identifier libraries andamplicon enrichment plan described herein.

To increase sequencing efficiency, it may be advantageous to optimizenanopore sequencing by physically concatenating identifiers in amplifiedsub-libraries. Nanopore sequencing may require target nucleic acidmolecules to find nanopores which contributes to reading speed. In orderto increase read time identifiers may be physically concatenated intolonger molecules by ligation. By increasing the length of sequencedmolecules from less than 500 bp to 5,000 bp (or greater), pore occupancymay be maximized.

The speed that nucleic acid molecules translocate through the nanoporemay be increased. Current nanopore sequencing instruments translocatenucleic acid molecules through nanopores at a rate of 500 base pairs persecond. Establishing a differential membrane potential (e.g., greaterthan 100 mV) across a nanopore membrane translocates nucleic acidmolecules at a higher rate (e.g., ˜1,000,000 bases per second). For mostsequencing applications, a rate on the order of hundreds of thousands istoo rapid and protein “motors” can be used to ratchet nucleic acidmolecules through the pore in order for a single distinct base to bedetected. Thus running nanopore sequencing without a “motor” may needgenerating single-stranded nucleic acid molecule input and amplificationof nucleic acid molecule signal. Several methods exist for asymmetricPCR that achieve greater than 50% single-stranded nucleic acid moleculesfrom a reaction. By adjusting primer-melting temperature, amplificationprimers can be designed to drive the reaction into linear amplificationof one strand. Alternatively, strand-specific exonucleases, such asLambda exonuclease, can be used to bind specifically to 5′phosphorylated nucleic acid molecule strands and selectively degrade onestrand of the duplex. The protocol may provide greater than 90%production of single-strand molecules.

Regarding signal amplification, nucleic acid molecules can be modifiedwith agents to enhance the signal to noise ratio, essentially creating a“super signature”. For example, agents can be small molecules, chemicalgroups, base analogues, enzymes, proteins, protein complexes, peptides,or amino acids. One method for nanopore signal enhancement, mTAG(methyltransferase-directed transfer of activated groups), uses amethyltransferase to add a chemical group, like biotinylatedS-adenosyl-L-methionine cofactor analogue, to the N6 atom of the adeninebase in a sequence motif. If the agent is a base analogue, it can beadded to the identifier molecule through PCR in which the base analogueis included in reaction mix and is incorporated into a complementarystrand bound to a single strand of the identifier molecule duringreplication. The new hybrid of identifier molecule with base analoguecan then be sequenced, and the base analogue can improve signal to noiseratio in a sequencing readout.

FIGS. 15A-B show DNA identifiers with signal events. In particular,FIGS. 15A-B show how modifying DNA with agents reduces conductanceresulting in an increase of signal, thereby increasing the signal tonoise ratio (SNR) associated with a sequencing event. Compared withunmodified DNA identifiers as shown in FIG. 15A, DNA identifiers withlarger chemical structures as shown in FIG. 15B reduce conductanceenhancing sequence signal. Graphs 1502, 1512 show signals (e.g.,representative signal events from solid-state pores) from sequencingidentifiers 1500 and 1510 respectively. Single and multiple modifiedbases can be used to create complex signal signatures defined by thetype of modifications, number of modifications, and spacing betweenmodifications. As shown, graph 1512 showing the signal of a modifiedidentifier read shows a higher SNR than graph 1502 showing the signal ofthe unmodified identifier read.

In some implementations, a protein motor may be used to translocatenucleic acid molecules through the nanopore. A protein may be selectedto increase the speed of translocation with the protein motor. Forexample, the translocation may be on the order of 1,000; 10,000;100,000; or 1,000,000 base per second. Current motor proteins may beoptimized to perform better at increased speeds. For example, publishedhelicase variants for motor speed include synthesizing multiple variantconstruct (using commercial DNA synthesis vendors).

The core decoding effort comprises signal decoding and error recovery.As an example, suppose that the archive is written as 10 pools, eachpool written with a component library of 113 component sequencespartitioned into 17 sets of five component sequences each and one set of28 component sequences. Each 25-bit source word is mapped to a 28-bitcodeword of weight 14 identifier sequences. The span of such acombinatorial space is 21.4×10¹² identifiers per pool, with the size ofany data encoding library being roughly 5.82×10¹² identifiers with4.16×10¹¹ reactions. Assuming uniform enrichment of each identifier, andsetting the incomplete sampling probability to 10⁻⁶, a sample of size44× the size of the pool of 5.82×10¹² identifiers is needed. Thus,sequencing a single pool will result in 256×10¹² reads. Assuming eachcomponent is 30 bases long, each read will be 540 bases in length,resulting in a sequence stream of approximate length 34.6 PB(petabytes). Instead, if the codeword weight is reduced to four, so thateach 14-bit source word is mapped to a 28-bit codeword of weight 4, thenthe span and the number of components that may be required remainunchanged, whereas the number of reactions increases to 2.97×10¹². Eachidentifier encodes 3.5 bits instead of 1.79 bits in the previous scheme,and the total reads are halved to 128×10¹² resulting in stream of length17.2 PB. Using the 34.6 PB estimate, a stream of about 34.6×10¹⁵ bytescan be processed in the span of 24 hours, which may require a throughputof 3.2×10¹² b/s. Graphics Processing Units (GPUs), like the NvidiaGeForce GTX Titan X GPU with 12 GB of memory connected to a highperformance Xeon CPU, may be used for approximate string matchingachieving between 0.35×10¹² and 1×10¹² b/s depending on text and patternlength, and allowed edit distance. Using 10 instances of Nvidia TeslaV100, and a GPU comparable to the GeForce Titan X offered by a cloudprovider, a higher signal decoding throughput may be achieved.

Assuming a writing error rate of 10⁻⁴ codewords, and the encoding schemedescribed above, we expect to see roughly 25 erroneous bits every 250000bits, or every 122 255-byte slices. Assuming independent uniformlyrandom errors, we thus expect a bit-error every four 255-byte slices.Thus, at the assumed error rate, at least 75% of all slices decodedwould be error free. If decoding an erroneous slice takes three times aslong as encoding it and decoding an error-free slice takes a third ofthe time as encoding it, the total decoding time works out to be roughlyequal to the encoding time.

The signal decoding GPU setup may be cloud-based. From this, and notdouble counting bandwidth and storage costs and including only thecompute cost for decoding as assumed above, the cost of reading data maybe significantly less than that required for bit-by-bit sequencingprocesses. This cost may be further reduced if all data storage andcomputing happens locally, rather than in the cloud.

FIG. 16 shows a system diagram of archival operations. The archive (CAR)is partitioned into boot, ontology, index, and content regions. The bootpartition may be written using a standard encoding scheme capable ofbeing decoded without any external metadata, and may store theparameters, keys, and addresses needed to read the other partitions. TheOS abstracts the storage medium as a collection of fixed size blocks, asdescribed above. Each block is a contiguous sequence of identifiersequences in a single identifier library, stored as a single pool ofidentifiers. (A block may, however, be mirrored in several pools forfault tolerance.) The OS can be responsible for organizing, allocating,and writing blocks. When the block layer receives a source bit streampacket, the block index divides and allocates the packet to blocks inthe archive. The boot partition comprises the block index, ahierarchical data structure mapping block IDs to physical addresses(comprised of container and identifiers). The block index tracksfree/used blocks and allocate blocks to new packets. Each block ID canbe a logical address and can be converted to a physical address in themolecular archive. This is achieved by traversing the Block Indexillustrated in FIG. 16. Each node in the data structure, called anaddress node, contains a sequence of child block id ranges, similar to aB-Tree data structure (e.g., as described below in relation to FIG. 18).Each range points to the next block on the path to the block ofinterest. In this way, a tree of address nodes is maintained culminatingin leaf nodes pointing to blocks in the molecular archive which containactual data. The leaf node so reached holds the block ID identifying,the physical address of the block, and can also hold the hash of theblock. Internal nodes can also contain a hash the concatenation of thehashes of its child nodes, thus forming a hash tree. The physicaladdress of a block comprises a Location Code, a Container Code, and anidentifier range defined by a start and end identifier that described aplurality of identifiers. A block ID may resolve to more than onephysical address to enable fault tolerance. For example, it may bespread across two or more disparate containers, or two or more disparateidentifier ranges.

At the molecular level, retrieval queries are answered using acombination of two operations: an identifier sub-library selectionoperation (for example, with the nested PCR or nested affinity tagaccess methods described above) and an identifier reading operation (forexample, with the impedance-based methods described above, or withsequencing-by-synthesis). Each operation has a positive cost and takes apositive amount of time, measured in minutes to hours. A selectionoperation may involve a number of sequential PCRs that recursivelyselect identifiers with a given fixed prefix of components. For an LCPCCwith L layers with each component sequence of length l_(c) bases,performing p sequential PCRs (SPCRs) on an identifier library willdecrease the identifier library diversity by θp layers, where θ is thenumber of layers covered by a single PCR. Thus, after p SPCRs onnon-multiplex layers, the identifiers present are diverse in L−θplayers. Each such identifier corresponds to (L−θp)l_(c) diverse bases.If a sequencing technique is capable of reading molecules of maximumlength 6, then the number p of SPCRs needed to be able to sequence anyidentifier after p SPCRs is constrained in the following way:

$p \geq {\frac{1}{\theta}{\left( {L - \begin{matrix}\sigma \\l_{c}\end{matrix}} \right).}}$

After p SPCRs where p satisfies the given constraint, an identifierlibrary of span D possible identifiers is truncated to an identifierlibrary containing D′ identifiers, where

${D^{\prime} = \frac{D}{c_{b}\theta_{p}}},$

where c_(b) is the number of components in any base layer of thepartition scheme. Assuming an encoding scheme with L=15 layers andc_(b)=6, l_(c)=30 bases, σ=300, and θ=4, gives p=2. In this case, thetruncated identifier library size D′≅6×10⁵≤10⁶ identifiers. For example,assuming a simple model of perfectly uniform enrichment of eachidentifier, the sample size that may be required to sample allidentifiers with high probability may be calculated using a CouponCollector model, and turns out to be S≥βD′ ln D′, where

${\beta = {1 - \frac{\ln \; \alpha}{\ln \; D^{\prime}}}},$

and α is the probability of an incomplete sample. Setting α=10′, givesβ=2, and approximately S≥28×10⁶, showing that a sample size of 28× thesize of the selected sub-library may be sufficient. Note that theuniform enrichment assumption is idealistic and the coverage may need tobe somewhat larger (but not extraordinarily so, given that non-uniformcoupon collection distributions are also known to be concentrated aroundthe mean). This allows a tolerance of a 10- to 100-fold higher value ofa.

The number of block operations needed may be calculated via thefollowing steps. As an example, consider data blocks of size 10⁶ bits inan archive of 10¹⁹ bits, roughly an Exabyte. The archive is composed of10¹³ data blocks partitioned into 10′ compartmentalized identifierlibraries, each containing 10¹² bits. Each identifier library contains10⁶ data blocks. If each blocks is represented by a continuous range ofordered identifiers, then each block may be completely defined by thesequence of components in its first identifier and that in its lastidentifier. For an L-layered scheme, with a component library of Ccomponents, a physical block address comprising an identifier range canthus be encoded using 2L[log₂ C] bits. Thus, if C=112 and L=15, then theidentifier range may be encoded in 27 bytes. By similar reasoning,encoding a physical container address may require at least 3 bytes. Atotal of 64 bytes may be allocated for encoding a physical block addresscomprising an identifier range and a physical container address. We canallocate 128 bytes to store a hash. Analogously, a source block ID forany block in the source bit stream may require 64 bytes. An address nodethat can support up to 512 child nodes may require 511 block ID rangemarkers and 512 pointers, each of which is a physical archive address(for example, container address and identifier range) of a child block.Thus, an address node may require 511×64+512×64+128 bytes, or 524,800bits. Including error correction bytes, such an address node would beencodable in a 10⁶-bit archive block. Thus, a 10⁶-bit archive blockcould be selected and read.

Using such a scheme, a hierarchical block addressing structure for anExabyte-scale archive would need to be no more than five levels deep.Starting from a “cold” cache of blocks, i.e., no blocks have beenqueried, a single-block access with a block ID may require at most sixselect-read operations: five select-read pairs to find the physicaladdress of the block in question (e.g. traversing through the B-tree),and one select-read pair to read the data block. The OS can use thisfoundation of a block and a block index to build an indexable archive.The basic unit of storage is a block and blocks refer to other blocksusing block ids which are mapped to physical addresses using the blockindex.

Each high level operation on a block of bits depends on and results in anumber of physical operations, which rely on chemical methods orphysical steps to be orchestrated. This can involve two types ofsoftware tools: optimization tools that translate block operations intoan optimized set of physical operations, and translation tools thatconvert physical operations into detailed programs of actions to beexecuted by technicians or automation devices, and may include designingand implementing a translator between operations on blocks of bits andphysical and chemical operations.

The OS can also allocate bottleneck resources—liquid handling robot andtechnician time for example—and schedule other write operations so as tominimize the make-span of a write operation. A read request may arisefrom a pattern query (as described below) and comprise reading a rangeof blocks specified by block IDs. Because a CAR index is organized as aB-Tree (e.g., as described below in relation to FIG. 18), each patternquery is likely to translate into an access of a range of adjacent wordsin a range of adjacent blocks.

Typically, pattern queries involve conjunctions and disjunctions and aretranslated into an optimized sequence of join operations to minimize theread footprint. The query optimizer used in the systems and methodsdescribed herein may be modified and augmented so as to faithfullyreflect the access cost model in a CAR. After join optimization, acomplex pattern query comprising conjunctions and disjunctions mayresult in a set of blocks to be read. The OS may generate chemical stepsfor reading the block index to convert block IDs into physical addresses(container and identifiers) and the steps for reading the target blocks.Reading a set of target blocks may require identifying the set ofprimers needed to execute a set of sequential PCRs as identified by thequery optimizer. The OS can generate instances of the SPCR and otherchemical methods, complete them with physical sample addresses andmethod parameter values like volume and concentration, and allocate allessential labware, instruments, and technicians. The overall frameworkcan be responsible for three tasks: time scheduling, resourceallocation, and compilation and generation of action programs. The OScan adapt extant frameworks from the business process modeling andautomation space such as jBPM and Camunda and from cloud workflow toolssuch as Simple Workflow Service and Logic Apps may be adapted for theframework.

The OS can interact with at least four automation devices: the writingsystem, the reading system, a liquid handling robot, and a sample andcontainer management system. The OS can translate the steps in theworkflows output by the physical and chemical translators automatable byany of these devices into device-specific instructions. The writingsystem can be programmed as to which sets of components to collocate,and may require the design and generation of a reaction specificationformat. FIG. 3 illustrates an example format, and shows how acombinatorial space may be used to encode a bit stream and serializedinto a reaction specification. In this example, a 5-bit codeword offixed weight three bits encodes a source word. The codeword istranslated into a combinatorial space of four base layers and amultiplex layer comprising five components, corresponding to the bits ina codeword. Each codeword is to be assembled in a single reaction, andeach reaction may include 4 base components and 3-of-5 multiplex layercomponents, or 7 components in total. A combinatorial space from alayered product constructor can be visualized as a trie and each pathfrom root to leaf in this trie is an identifier. The set of identifiersto be assembled in each reaction can be serialized by traversing thetrie in post order, as depicted at the bottom. This reaction setspecification is generated by the OS for each write job and packagedwith additional description information in the form of job and blockdescriptors, illustrated in FIG. 17.

FIG. 17 shows a writing workflow with a printer-finisher system,according to certain illustrative embodiments. Print job instructionsare split into print head controller command frames and sent toindividual print heads, each capable of printing up to four inks, eachink containing a single component. The writing system is equipped withcameras imaging nozzle test (chirp) signals. The OS will process thisimage data offline, estimate a write error rate, and generate rewriterequests for potentially missing identifiers until the error ratebecomes tractable by error protection scheme. The OS will also produceinstructions for directing a container management system to submit andcheckout containers, and generate container barcode labels. For anExabyte-scale archive, up to 10⁶ identifier libraries can be managed bya container bank such as the Hamilton Verso or the Brooks SampleStoreII. Such container banks also integrate with third party laboratoryinformation management systems (LIMS): for example, the Verso API issupported by LabVantage 8 LIMS and Mosaic. The Verso and Mosaic bothsupport programmatic control through RESTful APIs for integration withthe OS. The OS may also generate “pick-list” transfer instructions forliquid handlers to facilitate sample prep for sequencing and SPCRs.

The systems and methods described herein provide preservation,discovery, and querying of an archive incrementally, without requiringthe decoding large portions of the archive. It should be possible todiscovery, query, and read target content selectively and incrementally,while minimizing the need to compute joins and other structures on thearchive. A key metric to be minimized is the total number of bitsdecoded to satisfy a sequence of queries.

FIG. 18 shows an example of a data path for the writing system. Semanticannotation of data blocks may be provided and comprise a block ID, withrelational information linking them, and a compact index mapping termsto blocks for access. A Resource Description Framework (RDF) may be asthe framework implementing the discovery layer to address indexing anddiscoverability while minimizing cost of access and maximizing longevityof interpretation. RDF is a formal meta-language standardized by theWorld Wide Web Consortium for representing information about resourcesas a set of subject-predicate-object (SPO) triples encoding a graph ofentities. Key advantages of RDF can be leveraged, including the abilityto interlink blocks of data and even datasets, the integration ofdomain-specific vocabularies, and tooling for translation, indexing,compaction, and mining.

An archive can be factored into four partitions: bootup, ontology,index, and content. The ontology partition contains a vocabulary ofterms and classes and a list of the labels of all entities found in thearchive. As such, it offers a taxonomy of the contents of the archiveand is intended to facilitate targeted discovery while minimizing thedecode footprint. The ontology may be provided by the producer orconstructed during ingest using domain-specific software. The indexpartition can be organized as a triple-store. For example, it can storeseveral collections of lexicographically sorted triples—typicallybetween 6 and 18—with the goal of rapidly serving pattern queries. RDFquerying is by example and takes the form “select x₁, x₂, . . . x_(k)where {p₁ and p₂ and . . . p_(n)}”, where x₁ are data attributes ofinterest and pi are subject-predicate-object patterns, where each iseither a variable or a literal value. For example, “select name where{author <hasName> name and book <writtenBy> author and movie <basedOn>book and movie <directedBy> dir and dir <hasName>“Kubrick”}” returns thenames of all authors whose books were made into films directed by“Kubrick.” Because each element of a pattern may be a literal or avariable, any of the six permutations of SPO may be needed to search fortriples satisfying a pattern in a query. Additional indices storing allunary and binary relations (e.g. SO, SP, OS, etc.) with a count ofsatisfying triples may also be maintained. These indices are stored asB-Trees or as tries (as described below in relation to FIG. 18), whereliterals in a pattern serve as the key through the B-Tree or trie andthe satisfying triples are stored in blocks pointed to by leaf nodes.The RDF Header Dictionary Triples framework may be used to implementthis index organization and serialization scheme. While RDF literals maybe string URIs, these are mapped to integer ids when stored in theseindices. Because adjacent triples may share prefix literals, they can bestored as deltas in a compressed form and may be directly translatedinto ranges of identifiers.

An advantage of such a native semantic data storage is that a query maynow be satisfied without having to read and decode the entire index. Ananalyst-initiating discovery of an archive results in the decoding ofthe bootup and ontology partitions. These are disseminated to theanalyst from which the analyst may construct initial queries. A RDFquery engine (e.g. Redland Rasqal), coupled with the software describedherein, can transform this pattern query into an optimized set of scansthrough the B-Tree indices, and CAR blocks. The result may be a set ofsatisfying triples, and/or a set of estimated triple counts. Based onthese results, the analyst may submit further queries that may result indecoding of long-form target content comprising images, videos, orscientific datasets. Because indexing is natively integrated withApplicant storage, the decoded footprint can be minimized by the queryoptimizer.

Each entity included in the index is referred to by an integer ID, whichexpands to a Uniform Resource Identifier (URI). The entity referred toby the URI, however, is stored in the content partition, which mayoptionally have an additional compressed index. Compressed indices (e.g.a wavelet tree) enable multi-resolution access, multi-scheme writing,and fast searching, all with small space overheads.

FIG. 18 shows a flowchart 1800 outlining the steps for storing blocks ofdata associated with block identifications (IDs) in containers. At step1802, a plurality of blocks is obtained. Each block comprises a stringof symbols and is associated with a block ID. A block ID may be anyidentifying characteristic or symbol associated with a particular block.For example, it may be a semantic annotation in the form of a triple. Insome implementations, a block ID is an integer, a string, a triple, alist of attributes, or a semantic annotation. For example, the first Xsymbols of a string of symbols included in the block may indicate anumerical ID for that block.

At step 1804, a block (one of the blocks belonging to the plurality ofblocks received in step 1802) is assigned to a container. A containermay be a physical location, such as a bin, tube, or other physicalstorage medium where nucleic acid molecules may be stored. A containermay be linked to a single block or multiple blocks. For example, onecontainer may be associated with B blocks of information. In someembodiments, a container may comprise multiple sub-containers.

At step 1806, the block is mapped to identifier sequences to beassociated with the container. These identifiers may comprise anidentifier range or multiple disparate identifiers of identifier ranges.An identifier range may be specified by the component sequences thatcomprise the identifiers flanking the range. In some implementations,each individual identifier is associated with a distinct integer, suchthat an identifier range may be specified by two integers. An individualidentifier sequence of the plurality of identifier sequences correspondsto an individual symbol in the string of symbols stored in the block.Each identifier sequence includes a corresponding plurality of componentsequences. Each of these component sequences includes a distinct nucleicacid sequence.

At step 1808, individual identifiers of the plurality of identifiersequences are constructed. For example, a set of Q identifier sequencesmay be associated with a particular container. A subset V of those Qidentifier sequences may be physically constructed to representinformation in the block, as described in various methods describedabove.

At step 1810, the identifiers constructed in step 1808 are stored in theassigned container. For example, the assigned container may then hold anumber V of identifiers representing the information stored in theblock. Identities of the container and the plurality of identifiernucleic acid sequences associated therewith are configured to bedetermined using the associated block ID. In some implementations, theidentities are stored in a data structure designed to facilitate accessof the identity of each container using the associated block ID. Forexample, the data structure may be one of a B-tree, a trie, or an array.In some implementations, at least a portion of the data structure isstored along with the digital information in an index. The index mayinclude a second plurality of identifier sequences associated with asecond container. In some implementations, the index is stored in amagnetic storage device, an optical storage device, a flash memorydevice, or cloud storage

If the index includes a B-tree data structure, each node of the B-treemay include a distinct plurality of identifiers (i.e., different thanthe set of identifiers constructed in step 1808) of the second pluralityof identifier sequences. In some implementations, to determine theidentity of the distinct plurality of identifiers, the B-tree may besearched. Searching for a particular block ID in the B-tree may includeselecting the distinct plurality of identifiers that comprise a firstnode and reading a value of the first node. The steps of selecting anidentifier and reading a value of a node may be repeated with subsequentnodes. The identity of the distinct plurality of identifiers thatcomprise the subsequent node is determined by the blockID in relation tothe value of the first node. In an example, the first node is the rootnode of the B-tree and the process of selecting (with random accessmethod described above) and reading nodes continues until the value of aleaf node of the B-tree is read. The value of the leaf node isconfigured to communicate whether the block for the block ID exists. Ifthe block ID exists, the identity of the container and the identity ofthe plurality of identifier nucleic acid sequences comprising said block(for example, the identifier range) may be communicated to a user orsystem.

If the index comprises a trie data structure, each node of the trie maycomprise a distinct plurality of identifiers of the second plurality ofidentifier sequences. In some implementations, the block ID is a stringof symbols and each node in the trie corresponds to a possible prefix ofthe string of symbols. If a path through the trie for a block ID exists,then the physical address (comprised of the container and identifierrange or ranges) of the corresponding block can be specified by the leafnode of that path. Each intermediate node of the trie can be representedby a separate plurality of identifiers and can contain information onhow many daughter nodes it has, what symbols those daughter nodesrepresent, and the physical addresses (comprised of the containeridentity and identifier range or identifier ranges) of those daughternodes. In that way, the trie can be navigated in DNA, similar to theB-tree, using select-read operations as described above.

If the data structure is an array, each element of the array comprises adistinct plurality of identifiers of the second plurality of identifiersequences. In some implementations, each element in the arraycorresponds to a block ID and each element contains the physical address(comprised of the container identity and identifier range of ranges) ofthat block ID.

In some implementations, the location in the index of the identities (ofthe container and plurality of identifiers for each block) introduced instep 1810 described above is natively configured to the block ID. Theblock ID may map directly to a plurality of components that only and allidentifiers that contain the physical address of the block share. Theplurality of identifier nucleic acid molecules in the index that storesthe identities may be comprised of individual identifier nucleic acidmolecules that each comprise the plurality of components. In someimplementations, the block ID maps directly to the container and aplurality of nucleic acid components that only and all identifiers ofthe corresponding block in the container share. In some implementations,the block ID is a triple of entities that annotate the associated block,and an entity of the triple maps to a plurality of nucleic acidcomponents. The plurality of identifiers in the index that compriseindividual identifiers that comprise the components can store thephysical addresses of all blocks annotated with the entity.Alternatively or in addition, the plurality of identifiers in thecontent of an archive that comprise all blocks annotated by said entitymay exclusively comprise the corresponding plurality of nucleic acidcomponents that represent said entity.

A system for storing digital information according to any of the methodsdescribed herein (e.g., the methods described in relation to FIGS. 8-10,18) may include a sample management system for storing multiplecontainers of nucleic acids. The system may use automation machinery forretrieving a specified container from the sample management system. Insome implementations, this sample management system is used to accessany kind of containers—including the DNA-holding identifiers describedabove in relation to FIG. 18 but also including any kind of physical orcomputer represented data storage element.

The foregoing is merely illustrative of the principles of thedisclosure, and the apparatuses can be practiced by other than thedescribed embodiments, which are presented for purposes of illustrationand not of limitation. It is to be understood that the methods disclosedherein, while shown for use in nucleic acid-based data storage, may beapplied to systems in other applications requiring data storage.

Variations and modifications will occur to those of skill in the artafter reviewing this disclosure. The disclosed features may beimplemented, in any combination and subcombination (including multipledependent combinations and subcombinations), with one or more otherfeatures described herein. The various features described or illustratedabove, including any components thereof, may be combined or integratedin other systems. Moreover, certain features may be omitted or notimplemented.

The systems and methods described may be implemented locally on aprinter/finisher system. The printer/finisher system may include a dataprocessing apparatus. The systems and methods described herein may beimplemented remotely on a separate data processing apparatus. Theseparate data processing apparatus may be connected directly orindirectly to the printer/finisher system through cloud applications.The printer/finisher system may communicate with the separate dataprocessing apparatus in real-time (or near real-time).

In general, embodiments of the subject matter and the functionaloperations described in this specification can be implemented in digitalelectronic circuitry, or in computer software, firmware, or hardware,including the structures disclosed in this specification and theirstructural equivalents, or in combinations of one or more of them.Embodiments of the subject matter described in this specification can beimplemented as one or more computer program products, i.e., one or moremodules of computer program instructions encoded on a computer readablemedium for execution by, or to control the operation of, data processingapparatus. The computer readable medium can be a machine-readablestorage device, a machine-readable storage substrate, a memory device, acomposition of matter affecting a machine-readable propagated signal, ora combination of one or more of them. The term “data processingapparatus” encompasses all apparatus, devices, and machines forprocessing data, including by way of example a programmable processor, acomputer, or multiple processors or computers. The apparatus caninclude, in addition to hardware, code that creates an executionenvironment for the computer program in question, e.g., code thatconstitutes processor firmware, a protocol stack, a database managementsystem, an operating system, or a combination of one or more of them. Apropagated signal is an artificially generated signal, e.g., amachine-generated electrical, optical, or electromagnetic signal that isgenerated to encode information for transmission to suitable receiverapparatus.

A computer program (also known as a program, software, softwareapplication, script, or code) can be written in any form of programminglanguage, including compiled or interpreted languages, and it can bedeployed in any form, including as a stand-alone program or as a module,component, subroutine, or other unit suitable for use in a computingenvironment. A computer program may correspond to a file in a filesystem. A program can be stored in a portion of a file that holds otherprograms or data (e.g., one or more scripts stored in a markup languagedocument), in a single file dedicated to the program in question, or inmultiple coordinated files (e.g., files that store one or more modules,sub programs, or portions of code). A computer program can be deployedto be executed on one computer or on multiple computers that are locatedat one site or distributed across multiple sites and interconnected by acommunication network.

The processes and logic flows described in this specification can beperformed by one or more programmable processors executing one or morecomputer programs to perform functions by operating on input data andgenerating output. The processes and logic flows can also be performedby, and apparatus can also be implemented as, special purpose logiccircuitry, e.g., an FPGA (field programmable gate array) or an ASIC(application specific integrated circuit).

Processors suitable for the execution of a computer program include, byway of example, both general and special purpose microprocessors, andany one or more processors of any kind of digital computer. Generally, aprocessor will receive instructions and data from a read-only memory ora random access memory or both. The essential elements of a computer area processor for performing instructions and one or more memory devicesfor storing instructions and data. Generally, a computer will alsoinclude, or be operatively coupled to receive data from or transfer datato, or both, one or more mass storage devices for storing data, e.g.,magnetic, magneto optical disks, or optical disks. However, a computerneed not have such devices.

Examples of changes, substitutions, and alterations are ascertainable byone skilled in the art and could be made without departing from thescope of the information disclosed herein. All references cited hereinare incorporated by reference in their entirety and made part of thisapplication.

1. A method for reading information stored in nucleic acid sequences,the method comprising: obtaining a pool of identifier nucleic acidmolecules that store digital information from a string of symbols oflength L, wherein each individual identifier nucleic acid moleculecomprises a plurality of component nucleic acid molecules andcorresponds to a symbol value and a symbol position in the string ofsymbols, and wherein the pool of identifier nucleic acid moleculescorrespond to a subset of identifier nucleic acid sequences in anidentifier library that is capable of encoding any string of symbolshaving length L; reading an identifier nucleic acid molecule of theobtained identifier nucleic acid molecules to identify a read sequencecorresponding to a portion of the identifier nucleic acid molecule;identifying, based on the read sequence, a set of candidate identifiernucleic acid sequences each (i) corresponding to an entry in theidentifier library and (ii) comprising a component nucleic acid moleculehaving a sequence that approximates or exactly matches the readsequence; assigning, to each candidate identifier nucleic acid sequence,a score representative of how similar the respective candidateidentifier nucleic acid sequence is to the identifier nucleic acidmolecule; and selecting, based on the scores, one of the candidateidentifier nucleic acid sequences as a selected sequence.
 2. The methodof claim 1, further comprising using the identifier library to map theselected sequence to one of the symbol positions and one of the symbolvalues within the string of symbols.
 3. The method of claim 2, furthercomprising determining additional symbol positions and symbol valueswithin the string of symbols by using the identifier library to mapadditional selected sequences corresponding to likely sequences ofidentifier nucleic acid molecules in the pool.
 4. The method of claim 1,wherein reading the identifier nucleic acid molecule comprisessequencing at least a portion of the identifier nucleic acid molecule byat least one selected from the group of: chemical sequencing, chaintermination sequencing, shotgun sequencing, bridge PCR sequencing,single-molecule real-time sequencing, ion semiconductor sequencing,pyrosequencing, sequencing by synthesis, combinatorial probe anchorsynthesis sequencing, sequencing by ligation, nanopore sequencing,nanochannel sequencing, massively parallel signature sequencing, Polonysequencing, DNA nanoball sequencing, single molecule fluorescentsequencing, tunneling current sequencing, sequencing by hybridization,mass spectrometry sequencing, microfluidic sequencing, transmissionelectron microscopy sequencing, RNA polymerase sequencing, and in vitrovirus sequencing.
 5. The method of claim 4, wherein the sequencingcomprises: applying an electric field to an electrolytic solution and atleast one nanopore channel; translocating the identifier nucleic acidmolecule through the at least one nanopore channel; and measuringimpedance in the at least one nanopore channel, wherein the componentnucleic acid sequences each have a corresponding unique impedancesignature along the length of the sequence.
 6. The method of claim 5,wherein sequencing at least one component nucleic acid sequence in theidentifier nucleic acid molecule comprises comparing measured impedancevalues to the unique impedance signature.
 7. The method of claim 5,wherein the at least one nanopore channel is formed from at least oneselected from the group of alpha-hemolysin (αHL), Mycobacteriumsmegmatis porin A (MspA), and a solid state-membrane.
 8. (canceled) 9.The method of claim 5, further comprising, prior to reading anidentifier nucleic acid molecule, at least one selected from the groupof ligating the at least one identifier nucleic acid molecule to asecond identifier nucleic acid molecule and selectively degrading onestrand of the at least one identifier nucleic acid molecule using astrand-specific exonuclease. 10-12. (canceled)
 13. The method of claim5, further comprising, before translocating, binding an agent to the atleast one identifier nucleic acid molecule, wherein the agent isassociated with an agent signature in the measure impedance.
 14. Themethod of claim 13, wherein at least one unique impedance signaturecomprises the agent signature, and wherein determining at least onecomponent nucleic acid sequence in the identifier nucleic acid moleculecomprises comparing measured impedance values to said at least oneunique impedance signature.
 15. The method of claim 13, wherein apresence of the agent on the at least one nucleic acid molecule allowsfor a first maximum translocation rate that achieves a desired level ofaccuracy that is faster than a second maximum translocation rate thatachieves the desired level of accuracy in the absence of the agent onthe at least one nucleic acid molecule.
 16. The method of claim 13,wherein binding the agent to the at least one identifier nucleic acidmolecule comprises using an enzyme, and wherein binding the agent to theat least one identifier nucleic acid molecule occurs at a known locationon a component nucleic acid molecule such that the agent signature atthe known location results in a known shift in impedance value duringtranslocation.
 17. The method of claim 16, wherein the agent is a baseanalogue or a modified base, and the enzyme is a polymerase, wherein thepolymerase incorporates the base analogue or the modified base in the atleast one identifier nucleic acid molecule during replication.
 18. Themethod of claim 13, further comprising binding each agent of a pluralityof agents at known locations on the plurality of component nucleic acidmolecules, wherein the plurality of agents and known locations of eachagent comprise an agent signature.
 19. (canceled)
 20. The method ofclaim 1, wherein the obtained identifier nucleic acid molecules areencoded with a minimum number of base difference from one another suchthat each identifier nucleic acid molecule is associated with a readingerror tolerance that permits faster reading of the identifier nucleicacid molecule than identifier nucleic acid molecules that are encodedwith more than the minimum number of base difference from one another.21. (canceled)
 22. The method of claim 1, further comprising:determining, based on mapping the selected sequence to one of the symbolpositions and one of the symbol values within the string of symbols, adecoded string of symbols; calculating a hash of a portion of thedecoded string of symbols; comparing the calculated hash to an originalhash associated with a corresponding portion of the string of symbols;and verifying, based on the comparison, whether the portion of thedecoded string of symbols matches the portion of the string of symbols.23. The method of claim 22, further comprising: determining the portionof the decoded string of symbols does not match the portion of thestring of symbols; selecting, based on the scores, a second candidateidentifier nucleic acid sequence as the selected sequence; and using theidentifier library to map the selected sequence to one of the symbolpositions and one of the symbol values within the string of symbols. 24.(canceled)
 25. The method of claim 1, further comprising: computing asample size estimate for the pool of identifier nucleic acid molecules;and sampling the pool of identifier nucleic acid molecules, based on thesample size estimate, to obtain the identifier nucleic acid molecule.26. The method of claim 1, wherein each identifier nucleic acid moleculein the pool of nucleic acid molecules comprises M component nucleic acidmolecules corresponding to M layers, and wherein reading the identifiernucleic acid molecule includes reading N of the M layers, N being lessthan or equal to M. 27-28. (canceled)
 29. The method of claim 1, whereinthe score is a distance metric representative of a degree of similaritybetween the respective candidate identifier nucleic acid sequence andthe identifier nucleic acid molecule. 30-92. (canceled)